Vulkan-Hpp
vulkan_handles.hpp
Go to the documentation of this file.
1 // Copyright 2015-2024 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_HANDLES_HPP
9 #define VULKAN_HANDLES_HPP
10 
11 namespace VULKAN_HPP_NAMESPACE
12 {
13 
14  //===================================
15  //=== STRUCT forward declarations ===
16  //===================================
17 
18  //=== VK_VERSION_1_0 ===
19  struct Extent2D;
20  struct Extent3D;
21  struct Offset2D;
22  struct Offset3D;
23  struct Rect2D;
24  struct BaseInStructure;
25  struct BaseOutStructure;
26  struct BufferMemoryBarrier;
27  struct DispatchIndirectCommand;
28  struct DrawIndexedIndirectCommand;
29  struct DrawIndirectCommand;
30  struct ImageMemoryBarrier;
31  struct MemoryBarrier;
32  struct PipelineCacheHeaderVersionOne;
33  struct AllocationCallbacks;
34  struct ApplicationInfo;
35  struct FormatProperties;
36  struct ImageFormatProperties;
37  struct InstanceCreateInfo;
38  struct MemoryHeap;
39  struct MemoryType;
40  struct PhysicalDeviceFeatures;
41  struct PhysicalDeviceLimits;
42  struct PhysicalDeviceMemoryProperties;
43  struct PhysicalDeviceProperties;
44  struct PhysicalDeviceSparseProperties;
45  struct QueueFamilyProperties;
46  struct DeviceCreateInfo;
47  struct DeviceQueueCreateInfo;
48  struct ExtensionProperties;
49  struct LayerProperties;
50  struct SubmitInfo;
51  struct MappedMemoryRange;
52  struct MemoryAllocateInfo;
53  struct MemoryRequirements;
54  struct BindSparseInfo;
55  struct ImageSubresource;
56  struct SparseBufferMemoryBindInfo;
57  struct SparseImageFormatProperties;
58  struct SparseImageMemoryBind;
59  struct SparseImageMemoryBindInfo;
60  struct SparseImageMemoryRequirements;
61  struct SparseImageOpaqueMemoryBindInfo;
62  struct SparseMemoryBind;
63  struct FenceCreateInfo;
64  struct SemaphoreCreateInfo;
65  struct EventCreateInfo;
66  struct QueryPoolCreateInfo;
67  struct BufferCreateInfo;
68  struct BufferViewCreateInfo;
69  struct ImageCreateInfo;
70  struct SubresourceLayout;
71  struct ComponentMapping;
72  struct ImageSubresourceRange;
73  struct ImageViewCreateInfo;
74  struct ShaderModuleCreateInfo;
75  struct PipelineCacheCreateInfo;
76  struct ComputePipelineCreateInfo;
77  struct GraphicsPipelineCreateInfo;
78  struct PipelineColorBlendAttachmentState;
79  struct PipelineColorBlendStateCreateInfo;
80  struct PipelineDepthStencilStateCreateInfo;
81  struct PipelineDynamicStateCreateInfo;
82  struct PipelineInputAssemblyStateCreateInfo;
83  struct PipelineMultisampleStateCreateInfo;
84  struct PipelineRasterizationStateCreateInfo;
85  struct PipelineShaderStageCreateInfo;
86  struct PipelineTessellationStateCreateInfo;
87  struct PipelineVertexInputStateCreateInfo;
88  struct PipelineViewportStateCreateInfo;
89  struct SpecializationInfo;
90  struct SpecializationMapEntry;
91  struct StencilOpState;
92  struct VertexInputAttributeDescription;
93  struct VertexInputBindingDescription;
94  struct Viewport;
95  struct PipelineLayoutCreateInfo;
96  struct PushConstantRange;
97  struct SamplerCreateInfo;
98  struct CopyDescriptorSet;
99  struct DescriptorBufferInfo;
100  struct DescriptorImageInfo;
101  struct DescriptorPoolCreateInfo;
102  struct DescriptorPoolSize;
103  struct DescriptorSetAllocateInfo;
104  struct DescriptorSetLayoutBinding;
105  struct DescriptorSetLayoutCreateInfo;
106  struct WriteDescriptorSet;
107  struct AttachmentDescription;
108  struct AttachmentReference;
109  struct FramebufferCreateInfo;
110  struct RenderPassCreateInfo;
111  struct SubpassDependency;
112  struct SubpassDescription;
113  struct CommandPoolCreateInfo;
114  struct CommandBufferAllocateInfo;
115  struct CommandBufferBeginInfo;
116  struct CommandBufferInheritanceInfo;
117  struct BufferCopy;
118  struct BufferImageCopy;
119  struct ClearAttachment;
120  union ClearColorValue;
121  struct ClearDepthStencilValue;
122  struct ClearRect;
123  union ClearValue;
124  struct ImageBlit;
125  struct ImageCopy;
126  struct ImageResolve;
127  struct ImageSubresourceLayers;
128  struct RenderPassBeginInfo;
129 
130  //=== VK_VERSION_1_1 ===
131  struct PhysicalDeviceSubgroupProperties;
132  struct BindBufferMemoryInfo;
134  struct BindImageMemoryInfo;
148  struct DeviceGroupSubmitInfo;
166  struct MemoryRequirements2;
174  struct FormatProperties2;
176  struct ImageFormatProperties2;
180  struct QueueFamilyProperties2;
210  struct DeviceQueueInfo2;
211  struct ProtectedSubmitInfo;
250  struct ExportFenceCreateInfo;
264 
265  //=== VK_VERSION_1_2 ===
272  struct RenderPassCreateInfo2;
274  struct AttachmentDescription2;
276  struct AttachmentReference2;
278  struct SubpassDescription2;
280  struct SubpassDependency2;
282  struct SubpassBeginInfo;
284  struct SubpassEndInfo;
288  struct ConformanceVersion;
351  struct SemaphoreWaitInfo;
353  struct SemaphoreSignalInfo;
366 
367  //=== VK_VERSION_1_3 ===
388  struct MemoryBarrier2;
390  struct BufferMemoryBarrier2;
392  struct ImageMemoryBarrier2;
394  struct DependencyInfo;
396  struct SubmitInfo2;
398  struct SemaphoreSubmitInfo;
408  struct CopyBufferInfo2;
410  struct CopyImageInfo2;
412  struct CopyBufferToImageInfo2;
414  struct CopyImageToBufferInfo2;
416  struct BlitImageInfo2;
418  struct ResolveImageInfo2;
420  struct BufferCopy2;
422  struct ImageCopy2;
424  struct ImageBlit2;
426  struct BufferImageCopy2;
428  struct ImageResolve2;
447  struct RenderingInfo;
463  struct FormatProperties3;
473 
474  //=== VK_KHR_surface ===
475  struct SurfaceCapabilitiesKHR;
476  struct SurfaceFormatKHR;
477 
478  //=== VK_KHR_swapchain ===
479  struct SwapchainCreateInfoKHR;
480  struct PresentInfoKHR;
487 
488  //=== VK_KHR_display ===
494  struct DisplayPropertiesKHR;
496 
497  //=== VK_KHR_display_swapchain ===
498  struct DisplayPresentInfoKHR;
499 
500 #if defined( VK_USE_PLATFORM_XLIB_KHR )
501  //=== VK_KHR_xlib_surface ===
502  struct XlibSurfaceCreateInfoKHR;
503 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
504 
505 #if defined( VK_USE_PLATFORM_XCB_KHR )
506  //=== VK_KHR_xcb_surface ===
507  struct XcbSurfaceCreateInfoKHR;
508 #endif /*VK_USE_PLATFORM_XCB_KHR*/
509 
510 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
511  //=== VK_KHR_wayland_surface ===
512  struct WaylandSurfaceCreateInfoKHR;
513 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
514 
515 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
516  //=== VK_KHR_android_surface ===
517  struct AndroidSurfaceCreateInfoKHR;
518 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
519 
520 #if defined( VK_USE_PLATFORM_WIN32_KHR )
521  //=== VK_KHR_win32_surface ===
522  struct Win32SurfaceCreateInfoKHR;
523 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
524 
525  //=== VK_EXT_debug_report ===
527 
528  //=== VK_AMD_rasterization_order ===
530 
531  //=== VK_EXT_debug_marker ===
535 
536  //=== VK_KHR_video_queue ===
539  struct VideoProfileInfoKHR;
541  struct VideoCapabilitiesKHR;
552  struct VideoEndCodingInfoKHR;
554 
555  //=== VK_KHR_video_decode_queue ===
558  struct VideoDecodeInfoKHR;
559 
560  //=== VK_NV_dedicated_allocation ===
564 
565  //=== VK_EXT_transform_feedback ===
569 
570  //=== VK_NVX_binary_import ===
571  struct CuModuleCreateInfoNVX;
573  struct CuLaunchInfoNVX;
574 
575  //=== VK_NVX_image_view_handle ===
576  struct ImageViewHandleInfoNVX;
578 
579  //=== VK_KHR_video_encode_h264 ===
593  struct VideoEncodeH264QpKHR;
596 
597  //=== VK_KHR_video_encode_h265 ===
611  struct VideoEncodeH265QpKHR;
614 
615  //=== VK_KHR_video_decode_h264 ===
622 
623  //=== VK_AMD_texture_gather_bias_lod ===
625 
626  //=== VK_AMD_shader_info ===
627  struct ShaderResourceUsageAMD;
629 
630  //=== VK_KHR_dynamic_rendering ===
636 
637 #if defined( VK_USE_PLATFORM_GGP )
638  //=== VK_GGP_stream_descriptor_surface ===
639  struct StreamDescriptorSurfaceCreateInfoGGP;
640 #endif /*VK_USE_PLATFORM_GGP*/
641 
642  //=== VK_NV_corner_sampled_image ===
644 
645  //=== VK_NV_external_memory_capabilities ===
647 
648  //=== VK_NV_external_memory ===
651 
652 #if defined( VK_USE_PLATFORM_WIN32_KHR )
653  //=== VK_NV_external_memory_win32 ===
654  struct ImportMemoryWin32HandleInfoNV;
655  struct ExportMemoryWin32HandleInfoNV;
656 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
657 
658 #if defined( VK_USE_PLATFORM_WIN32_KHR )
659  //=== VK_NV_win32_keyed_mutex ===
660  struct Win32KeyedMutexAcquireReleaseInfoNV;
661 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
662 
663  //=== VK_EXT_validation_flags ===
664  struct ValidationFlagsEXT;
665 
666 #if defined( VK_USE_PLATFORM_VI_NN )
667  //=== VK_NN_vi_surface ===
668  struct ViSurfaceCreateInfoNN;
669 #endif /*VK_USE_PLATFORM_VI_NN*/
670 
671  //=== VK_EXT_astc_decode_mode ===
674 
675  //=== VK_EXT_pipeline_robustness ===
679 
680 #if defined( VK_USE_PLATFORM_WIN32_KHR )
681  //=== VK_KHR_external_memory_win32 ===
682  struct ImportMemoryWin32HandleInfoKHR;
683  struct ExportMemoryWin32HandleInfoKHR;
684  struct MemoryWin32HandlePropertiesKHR;
685  struct MemoryGetWin32HandleInfoKHR;
686 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
687 
688  //=== VK_KHR_external_memory_fd ===
689  struct ImportMemoryFdInfoKHR;
690  struct MemoryFdPropertiesKHR;
691  struct MemoryGetFdInfoKHR;
692 
693 #if defined( VK_USE_PLATFORM_WIN32_KHR )
694  //=== VK_KHR_win32_keyed_mutex ===
695  struct Win32KeyedMutexAcquireReleaseInfoKHR;
696 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
697 
698 #if defined( VK_USE_PLATFORM_WIN32_KHR )
699  //=== VK_KHR_external_semaphore_win32 ===
700  struct ImportSemaphoreWin32HandleInfoKHR;
701  struct ExportSemaphoreWin32HandleInfoKHR;
702  struct D3D12FenceSubmitInfoKHR;
703  struct SemaphoreGetWin32HandleInfoKHR;
704 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
705 
706  //=== VK_KHR_external_semaphore_fd ===
708  struct SemaphoreGetFdInfoKHR;
709 
710  //=== VK_KHR_push_descriptor ===
712 
713  //=== VK_EXT_conditional_rendering ===
717 
718  //=== VK_KHR_incremental_present ===
719  struct PresentRegionsKHR;
720  struct PresentRegionKHR;
721  struct RectLayerKHR;
722 
723  //=== VK_NV_clip_space_w_scaling ===
724  struct ViewportWScalingNV;
726 
727  //=== VK_EXT_display_surface_counter ===
729 
730  //=== VK_EXT_display_control ===
731  struct DisplayPowerInfoEXT;
732  struct DeviceEventInfoEXT;
733  struct DisplayEventInfoEXT;
735 
736  //=== VK_GOOGLE_display_timing ===
739  struct PresentTimesInfoGOOGLE;
740  struct PresentTimeGOOGLE;
741 
742  //=== VK_NVX_multiview_per_view_attributes ===
744 
745  //=== VK_NV_viewport_swizzle ===
746  struct ViewportSwizzleNV;
748 
749  //=== VK_EXT_discard_rectangles ===
752 
753  //=== VK_EXT_conservative_rasterization ===
756 
757  //=== VK_EXT_depth_clip_enable ===
760 
761  //=== VK_EXT_hdr_metadata ===
762  struct HdrMetadataEXT;
763  struct XYColorEXT;
764 
765  //=== VK_IMG_relaxed_line_rasterization ===
767 
768  //=== VK_KHR_shared_presentable_image ===
770 
771 #if defined( VK_USE_PLATFORM_WIN32_KHR )
772  //=== VK_KHR_external_fence_win32 ===
773  struct ImportFenceWin32HandleInfoKHR;
774  struct ExportFenceWin32HandleInfoKHR;
775  struct FenceGetWin32HandleInfoKHR;
776 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
777 
778  //=== VK_KHR_external_fence_fd ===
779  struct ImportFenceFdInfoKHR;
780  struct FenceGetFdInfoKHR;
781 
782  //=== VK_KHR_performance_query ===
785  struct PerformanceCounterKHR;
791 
792  //=== VK_KHR_get_surface_capabilities2 ===
795  struct SurfaceFormat2KHR;
796 
797  //=== VK_KHR_get_display_properties2 ===
798  struct DisplayProperties2KHR;
801  struct DisplayPlaneInfo2KHR;
803 
804 #if defined( VK_USE_PLATFORM_IOS_MVK )
805  //=== VK_MVK_ios_surface ===
806  struct IOSSurfaceCreateInfoMVK;
807 #endif /*VK_USE_PLATFORM_IOS_MVK*/
808 
809 #if defined( VK_USE_PLATFORM_MACOS_MVK )
810  //=== VK_MVK_macos_surface ===
811  struct MacOSSurfaceCreateInfoMVK;
812 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
813 
814  //=== VK_EXT_debug_utils ===
815  struct DebugUtilsLabelEXT;
820 
821 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
822  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
823  struct AndroidHardwareBufferUsageANDROID;
824  struct AndroidHardwareBufferPropertiesANDROID;
825  struct AndroidHardwareBufferFormatPropertiesANDROID;
826  struct ImportAndroidHardwareBufferInfoANDROID;
827  struct MemoryGetAndroidHardwareBufferInfoANDROID;
828  struct ExternalFormatANDROID;
829  struct AndroidHardwareBufferFormatProperties2ANDROID;
830 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
831 
832 #if defined( VK_ENABLE_BETA_EXTENSIONS )
833  //=== VK_AMDX_shader_enqueue ===
838  struct DispatchGraphInfoAMDX;
842 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
843 
844  //=== VK_EXT_sample_locations ===
845  struct SampleLocationEXT;
846  struct SampleLocationsInfoEXT;
853 
854  //=== VK_EXT_blend_operation_advanced ===
858 
859  //=== VK_NV_fragment_coverage_to_color ===
861 
862  //=== VK_KHR_acceleration_structure ===
866  struct AabbPositionsKHR;
869  struct TransformMatrixKHR;
888 
889  //=== VK_KHR_ray_tracing_pipeline ===
897 
898  //=== VK_KHR_ray_query ===
900 
901  //=== VK_NV_framebuffer_mixed_samples ===
903 
904  //=== VK_NV_shader_sm_builtins ===
907 
908  //=== VK_EXT_image_drm_format_modifier ===
917 
918  //=== VK_EXT_validation_cache ===
921 
922 #if defined( VK_ENABLE_BETA_EXTENSIONS )
923  //=== VK_KHR_portability_subset ===
926 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
927 
928  //=== VK_NV_shading_rate_image ===
929  struct ShadingRatePaletteNV;
933  struct CoarseSampleLocationNV;
936 
937  //=== VK_NV_ray_tracing ===
940  struct GeometryTrianglesNV;
941  struct GeometryAABBNV;
942  struct GeometryDataNV;
943  struct GeometryNV;
950 
951  //=== VK_NV_representative_fragment_test ===
954 
955  //=== VK_EXT_filter_cubic ===
958 
959  //=== VK_EXT_external_memory_host ===
963 
964  //=== VK_KHR_shader_clock ===
966 
967  //=== VK_AMD_pipeline_compiler_control ===
969 
970  //=== VK_AMD_shader_core_properties ===
972 
973  //=== VK_KHR_video_decode_h265 ===
980 
981  //=== VK_KHR_global_priority ===
988 
989  //=== VK_AMD_memory_overallocation_behavior ===
991 
992  //=== VK_EXT_vertex_attribute_divisor ===
994 
995 #if defined( VK_USE_PLATFORM_GGP )
996  //=== VK_GGP_frame_token ===
997  struct PresentFrameTokenGGP;
998 #endif /*VK_USE_PLATFORM_GGP*/
999 
1000  //=== VK_NV_compute_shader_derivatives ===
1002 
1003  //=== VK_NV_mesh_shader ===
1007 
1008  //=== VK_NV_shader_image_footprint ===
1010 
1011  //=== VK_NV_scissor_exclusive ===
1014 
1015  //=== VK_NV_device_diagnostic_checkpoints ===
1017  struct CheckpointDataNV;
1018 
1019  //=== VK_INTEL_shader_integer_functions2 ===
1021 
1022  //=== VK_INTEL_performance_query ===
1024  struct PerformanceValueINTEL;
1032 
1033  //=== VK_EXT_pci_bus_info ===
1035 
1036  //=== VK_AMD_display_native_hdr ===
1039 
1040 #if defined( VK_USE_PLATFORM_FUCHSIA )
1041  //=== VK_FUCHSIA_imagepipe_surface ===
1042  struct ImagePipeSurfaceCreateInfoFUCHSIA;
1043 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1044 
1045 #if defined( VK_USE_PLATFORM_METAL_EXT )
1046  //=== VK_EXT_metal_surface ===
1047  struct MetalSurfaceCreateInfoEXT;
1048 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1049 
1050  //=== VK_EXT_fragment_density_map ===
1054 
1055  //=== VK_KHR_fragment_shading_rate ===
1061 
1062  //=== VK_AMD_shader_core_properties2 ===
1064 
1065  //=== VK_AMD_device_coherent_memory ===
1067 
1068  //=== VK_EXT_shader_image_atomic_int64 ===
1070 
1071  //=== VK_EXT_memory_budget ===
1073 
1074  //=== VK_EXT_memory_priority ===
1077 
1078  //=== VK_KHR_surface_protected_capabilities ===
1080 
1081  //=== VK_NV_dedicated_allocation_image_aliasing ===
1083 
1084  //=== VK_EXT_buffer_device_address ===
1088 
1089  //=== VK_EXT_validation_features ===
1090  struct ValidationFeaturesEXT;
1091 
1092  //=== VK_KHR_present_wait ===
1094 
1095  //=== VK_NV_cooperative_matrix ===
1099 
1100  //=== VK_NV_coverage_reduction_mode ===
1104 
1105  //=== VK_EXT_fragment_shader_interlock ===
1107 
1108  //=== VK_EXT_ycbcr_image_arrays ===
1110 
1111  //=== VK_EXT_provoking_vertex ===
1115 
1116 #if defined( VK_USE_PLATFORM_WIN32_KHR )
1117  //=== VK_EXT_full_screen_exclusive ===
1118  struct SurfaceFullScreenExclusiveInfoEXT;
1119  struct SurfaceCapabilitiesFullScreenExclusiveEXT;
1120  struct SurfaceFullScreenExclusiveWin32InfoEXT;
1121 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
1122 
1123  //=== VK_EXT_headless_surface ===
1125 
1126  //=== VK_EXT_line_rasterization ===
1130 
1131  //=== VK_EXT_shader_atomic_float ===
1133 
1134  //=== VK_EXT_index_type_uint8 ===
1136 
1137  //=== VK_EXT_extended_dynamic_state ===
1139 
1140  //=== VK_KHR_pipeline_executable_properties ===
1142  struct PipelineInfoKHR;
1149 
1150  //=== VK_EXT_host_image_copy ===
1153  struct MemoryToImageCopyEXT;
1154  struct ImageToMemoryCopyEXT;
1155  struct CopyMemoryToImageInfoEXT;
1156  struct CopyImageToMemoryInfoEXT;
1157  struct CopyImageToImageInfoEXT;
1161 
1162  //=== VK_KHR_map_memory2 ===
1163  struct MemoryMapInfoKHR;
1164  struct MemoryUnmapInfoKHR;
1165 
1166  //=== VK_EXT_shader_atomic_float2 ===
1168 
1169  //=== VK_EXT_surface_maintenance1 ===
1170  struct SurfacePresentModeEXT;
1173 
1174  //=== VK_EXT_swapchain_maintenance1 ===
1181 
1182  //=== VK_NV_device_generated_commands ===
1191  struct IndirectCommandsStreamNV;
1194  struct GeneratedCommandsInfoNV;
1196 
1197  //=== VK_NV_inherited_viewport_scissor ===
1200 
1201  //=== VK_EXT_texel_buffer_alignment ===
1203 
1204  //=== VK_QCOM_render_pass_transform ===
1207 
1208  //=== VK_EXT_depth_bias_control ===
1210  struct DepthBiasInfoEXT;
1212 
1213  //=== VK_EXT_device_memory_report ===
1217 
1218  //=== VK_EXT_robustness2 ===
1221 
1222  //=== VK_EXT_custom_border_color ===
1226 
1227  //=== VK_KHR_pipeline_library ===
1229 
1230  //=== VK_NV_present_barrier ===
1234 
1235  //=== VK_KHR_present_id ===
1236  struct PresentIdKHR;
1238 
1239  //=== VK_KHR_video_encode_queue ===
1240  struct VideoEncodeInfoKHR;
1243  struct VideoEncodeUsageInfoKHR;
1251 
1252  //=== VK_NV_device_diagnostics_config ===
1255 
1256 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1257  //=== VK_NV_cuda_kernel_launch ===
1258  struct CudaModuleCreateInfoNV;
1259  struct CudaFunctionCreateInfoNV;
1260  struct CudaLaunchInfoNV;
1263 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1264 
1265  //=== VK_NV_low_latency ===
1266  struct QueryLowLatencySupportNV;
1267 
1268 #if defined( VK_USE_PLATFORM_METAL_EXT )
1269  //=== VK_EXT_metal_objects ===
1270  struct ExportMetalObjectCreateInfoEXT;
1271  struct ExportMetalObjectsInfoEXT;
1272  struct ExportMetalDeviceInfoEXT;
1273  struct ExportMetalCommandQueueInfoEXT;
1274  struct ExportMetalBufferInfoEXT;
1275  struct ImportMetalBufferInfoEXT;
1276  struct ExportMetalTextureInfoEXT;
1277  struct ImportMetalTextureInfoEXT;
1278  struct ExportMetalIOSurfaceInfoEXT;
1279  struct ImportMetalIOSurfaceInfoEXT;
1280  struct ExportMetalSharedEventInfoEXT;
1281  struct ImportMetalSharedEventInfoEXT;
1282 #endif /*VK_USE_PLATFORM_METAL_EXT*/
1283 
1284  //=== VK_KHR_synchronization2 ===
1286  struct CheckpointData2NV;
1287 
1288  //=== VK_EXT_descriptor_buffer ===
1292  struct DescriptorAddressInfoEXT;
1295  union DescriptorDataEXT;
1296  struct DescriptorGetInfoEXT;
1303 
1304  //=== VK_EXT_graphics_pipeline_library ===
1308 
1309  //=== VK_AMD_shader_early_and_late_fragment_tests ===
1311 
1312  //=== VK_KHR_fragment_shader_barycentric ===
1316 
1317  //=== VK_KHR_shader_subgroup_uniform_control_flow ===
1319 
1320  //=== VK_NV_fragment_shading_rate_enums ===
1324 
1325  //=== VK_NV_ray_tracing_motion_blur ===
1332  struct SRTDataNV;
1334 
1335  //=== VK_EXT_mesh_shader ===
1339 
1340  //=== VK_EXT_ycbcr_2plane_444_formats ===
1342 
1343  //=== VK_EXT_fragment_density_map2 ===
1346 
1347  //=== VK_QCOM_rotated_copy_commands ===
1349 
1350  //=== VK_KHR_workgroup_memory_explicit_layout ===
1352 
1353  //=== VK_EXT_image_compression_control ===
1357 
1358  //=== VK_EXT_attachment_feedback_loop_layout ===
1360 
1361  //=== VK_EXT_4444_formats ===
1363 
1364  //=== VK_EXT_device_fault ===
1366  struct DeviceFaultCountsEXT;
1367  struct DeviceFaultInfoEXT;
1369  struct DeviceFaultVendorInfoEXT;
1371 
1372  //=== VK_EXT_rgba10x6_formats ===
1374 
1375 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
1376  //=== VK_EXT_directfb_surface ===
1377  struct DirectFBSurfaceCreateInfoEXT;
1378 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
1379 
1380  //=== VK_EXT_vertex_input_dynamic_state ===
1384 
1385  //=== VK_EXT_physical_device_drm ===
1387 
1388  //=== VK_EXT_device_address_binding_report ===
1391 
1392  //=== VK_EXT_depth_clip_control ===
1395 
1396  //=== VK_EXT_primitive_topology_list_restart ===
1398 
1399 #if defined( VK_USE_PLATFORM_FUCHSIA )
1400  //=== VK_FUCHSIA_external_memory ===
1401  struct ImportMemoryZirconHandleInfoFUCHSIA;
1402  struct MemoryZirconHandlePropertiesFUCHSIA;
1403  struct MemoryGetZirconHandleInfoFUCHSIA;
1404 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1405 
1406 #if defined( VK_USE_PLATFORM_FUCHSIA )
1407  //=== VK_FUCHSIA_external_semaphore ===
1408  struct ImportSemaphoreZirconHandleInfoFUCHSIA;
1409  struct SemaphoreGetZirconHandleInfoFUCHSIA;
1410 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1411 
1412 #if defined( VK_USE_PLATFORM_FUCHSIA )
1413  //=== VK_FUCHSIA_buffer_collection ===
1414  struct BufferCollectionCreateInfoFUCHSIA;
1415  struct ImportMemoryBufferCollectionFUCHSIA;
1416  struct BufferCollectionImageCreateInfoFUCHSIA;
1417  struct BufferConstraintsInfoFUCHSIA;
1418  struct BufferCollectionBufferCreateInfoFUCHSIA;
1419  struct BufferCollectionPropertiesFUCHSIA;
1420  struct SysmemColorSpaceFUCHSIA;
1421  struct ImageConstraintsInfoFUCHSIA;
1422  struct ImageFormatConstraintsInfoFUCHSIA;
1423  struct BufferCollectionConstraintsInfoFUCHSIA;
1424 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1425 
1426  //=== VK_HUAWEI_subpass_shading ===
1430 
1431  //=== VK_HUAWEI_invocation_mask ===
1433 
1434  //=== VK_NV_external_memory_rdma ===
1437 
1438  //=== VK_EXT_pipeline_properties ===
1441 
1442  //=== VK_EXT_frame_boundary ===
1444  struct FrameBoundaryEXT;
1445 
1446  //=== VK_EXT_multisampled_render_to_single_sampled ===
1450 
1451  //=== VK_EXT_extended_dynamic_state2 ===
1453 
1454 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1455  //=== VK_QNX_screen_surface ===
1456  struct ScreenSurfaceCreateInfoQNX;
1457 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1458 
1459  //=== VK_EXT_color_write_enable ===
1462 
1463  //=== VK_EXT_primitives_generated_query ===
1465 
1466  //=== VK_KHR_ray_tracing_maintenance1 ===
1469 
1470  //=== VK_EXT_image_view_min_lod ===
1473 
1474  //=== VK_EXT_multi_draw ===
1477  struct MultiDrawInfoEXT;
1478  struct MultiDrawIndexedInfoEXT;
1479 
1480  //=== VK_EXT_image_2d_view_of_3d ===
1482 
1483  //=== VK_EXT_shader_tile_image ===
1486 
1487  //=== VK_EXT_opacity_micromap ===
1488  struct MicromapBuildInfoEXT;
1489  struct MicromapUsageEXT;
1490  struct MicromapCreateInfoEXT;
1493  struct MicromapVersionInfoEXT;
1496  struct CopyMicromapInfoEXT;
1499  struct MicromapTriangleEXT;
1500 
1501 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1502  //=== VK_NV_displacement_micromap ===
1506 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1507 
1508  //=== VK_HUAWEI_cluster_culling_shader ===
1512 
1513  //=== VK_EXT_border_color_swizzle ===
1516 
1517  //=== VK_EXT_pageable_device_local_memory ===
1519 
1520  //=== VK_ARM_shader_core_properties ===
1522 
1523  //=== VK_ARM_scheduling_controls ===
1527 
1528  //=== VK_EXT_image_sliced_view_of_3d ===
1531 
1532  //=== VK_VALVE_descriptor_set_host_mapping ===
1536 
1537  //=== VK_EXT_depth_clamp_zero_one ===
1539 
1540  //=== VK_EXT_non_seamless_cube_map ===
1542 
1543  //=== VK_ARM_render_pass_striped ===
1547  struct RenderPassStripeInfoARM;
1549 
1550  //=== VK_QCOM_fragment_density_map_offset ===
1554 
1555  //=== VK_NV_copy_memory_indirect ===
1560 
1561  //=== VK_NV_memory_decompression ===
1562  struct DecompressMemoryRegionNV;
1565 
1566  //=== VK_NV_device_generated_commands_compute ===
1571 
1572  //=== VK_NV_linear_color_attachment ===
1574 
1575  //=== VK_EXT_image_compression_control_swapchain ===
1577 
1578  //=== VK_QCOM_image_processing ===
1582 
1583  //=== VK_EXT_nested_command_buffer ===
1586 
1587  //=== VK_EXT_external_memory_acquire_unmodified ===
1589 
1590  //=== VK_EXT_extended_dynamic_state3 ===
1593  struct ColorBlendEquationEXT;
1594  struct ColorBlendAdvancedEXT;
1595 
1596  //=== VK_EXT_subpass_merge_feedback ===
1603 
1604  //=== VK_LUNARG_direct_driver_loading ===
1607 
1608  //=== VK_EXT_shader_module_identifier ===
1613 
1614  //=== VK_EXT_rasterization_order_attachment_access ===
1617 
1618  //=== VK_NV_optical_flow ===
1625  struct OpticalFlowExecuteInfoNV;
1626 
1627  //=== VK_EXT_legacy_dithering ===
1629 
1630  //=== VK_EXT_pipeline_protected_access ===
1632 
1633 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
1634  //=== VK_ANDROID_external_format_resolve ===
1635  struct PhysicalDeviceExternalFormatResolveFeaturesANDROID;
1636  struct PhysicalDeviceExternalFormatResolvePropertiesANDROID;
1637  struct AndroidHardwareBufferFormatResolvePropertiesANDROID;
1638 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1639 
1640  //=== VK_KHR_maintenance5 ===
1643  struct RenderingAreaInfoKHR;
1645  struct ImageSubresource2KHR;
1647  struct SubresourceLayout2KHR;
1651 
1652  //=== VK_KHR_ray_tracing_position_fetch ===
1654 
1655  //=== VK_EXT_shader_object ===
1658  struct ShaderCreateInfoEXT;
1659 
1660  //=== VK_QCOM_tile_properties ===
1662  struct TilePropertiesQCOM;
1663 
1664  //=== VK_SEC_amigo_profiling ===
1667 
1668  //=== VK_QCOM_multiview_per_view_viewports ===
1670 
1671  //=== VK_NV_ray_tracing_invocation_reorder ===
1674 
1675  //=== VK_NV_extended_sparse_address_space ===
1678 
1679  //=== VK_EXT_mutable_descriptor_type ===
1686 
1687  //=== VK_EXT_layer_settings ===
1689  struct LayerSettingEXT;
1690 
1691  //=== VK_ARM_shader_core_builtins ===
1694 
1695  //=== VK_EXT_pipeline_library_group_handles ===
1697 
1698  //=== VK_EXT_dynamic_rendering_unused_attachments ===
1700 
1701  //=== VK_NV_low_latency2 ===
1702  struct LatencySleepModeInfoNV;
1703  struct LatencySleepInfoNV;
1704  struct SetLatencyMarkerInfoNV;
1705  struct GetLatencyMarkerInfoNV;
1709  struct OutOfBandQueueTypeInfoNV;
1711 
1712  //=== VK_KHR_cooperative_matrix ===
1716 
1717  //=== VK_QCOM_multiview_per_view_render_areas ===
1720 
1721  //=== VK_KHR_video_maintenance1 ===
1723  struct VideoInlineQueryInfoKHR;
1724 
1725  //=== VK_NV_per_stage_descriptor_set ===
1727 
1728  //=== VK_QCOM_image_processing2 ===
1732 
1733  //=== VK_QCOM_filter_cubic_weights ===
1737 
1738  //=== VK_QCOM_ycbcr_degamma ===
1741 
1742  //=== VK_QCOM_filter_cubic_clamp ===
1744 
1745  //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
1747 
1748  //=== VK_KHR_vertex_attribute_divisor ===
1756 
1757 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
1758  //=== VK_QNX_external_memory_screen_buffer ===
1759  struct ScreenBufferPropertiesQNX;
1760  struct ScreenBufferFormatPropertiesQNX;
1761  struct ImportScreenBufferInfoQNX;
1762  struct ExternalFormatQNX;
1763  struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
1764 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1765 
1766  //=== VK_MSFT_layered_driver ===
1768 
1769  //=== VK_KHR_calibrated_timestamps ===
1772 
1773  //=== VK_KHR_maintenance6 ===
1776  struct BindMemoryStatusKHR;
1778  struct PushConstantsInfoKHR;
1779  struct PushDescriptorSetInfoKHR;
1783 
1784  //=== VK_NV_descriptor_pool_overallocation ===
1786 
1787  //===================================
1788  //=== HANDLE forward declarations ===
1789  //===================================
1790 
1791  //=== VK_VERSION_1_0 ===
1792  class Instance;
1793  class PhysicalDevice;
1794  class Device;
1795  class Queue;
1796  class DeviceMemory;
1797  class Fence;
1798  class Semaphore;
1799  class Event;
1800  class QueryPool;
1801  class Buffer;
1802  class BufferView;
1803  class Image;
1804  class ImageView;
1805  class ShaderModule;
1806  class PipelineCache;
1807  class Pipeline;
1808  class PipelineLayout;
1809  class Sampler;
1810  class DescriptorPool;
1811  class DescriptorSet;
1812  class DescriptorSetLayout;
1813  class Framebuffer;
1814  class RenderPass;
1815  class CommandPool;
1816  class CommandBuffer;
1817 
1818  //=== VK_VERSION_1_1 ===
1819  class SamplerYcbcrConversion;
1821 
1822  //=== VK_VERSION_1_3 ===
1823  class PrivateDataSlot;
1824 
1825  //=== VK_KHR_surface ===
1826  class SurfaceKHR;
1827 
1828  //=== VK_KHR_swapchain ===
1829  class SwapchainKHR;
1830 
1831  //=== VK_KHR_display ===
1832  class DisplayKHR;
1833  class DisplayModeKHR;
1834 
1835  //=== VK_EXT_debug_report ===
1836  class DebugReportCallbackEXT;
1837 
1838  //=== VK_KHR_video_queue ===
1839  class VideoSessionKHR;
1841 
1842  //=== VK_NVX_binary_import ===
1843  class CuModuleNVX;
1844  class CuFunctionNVX;
1845 
1846  //=== VK_EXT_debug_utils ===
1847  class DebugUtilsMessengerEXT;
1848 
1849  //=== VK_KHR_acceleration_structure ===
1851 
1852  //=== VK_EXT_validation_cache ===
1853  class ValidationCacheEXT;
1854 
1855  //=== VK_NV_ray_tracing ===
1857 
1858  //=== VK_INTEL_performance_query ===
1860 
1861  //=== VK_KHR_deferred_host_operations ===
1862  class DeferredOperationKHR;
1863 
1864  //=== VK_NV_device_generated_commands ===
1866 
1867 #if defined( VK_ENABLE_BETA_EXTENSIONS )
1868  //=== VK_NV_cuda_kernel_launch ===
1869  class CudaModuleNV;
1870  class CudaFunctionNV;
1871 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
1872 
1873 #if defined( VK_USE_PLATFORM_FUCHSIA )
1874  //=== VK_FUCHSIA_buffer_collection ===
1875  class BufferCollectionFUCHSIA;
1876 #endif /*VK_USE_PLATFORM_FUCHSIA*/
1877 
1878  //=== VK_EXT_opacity_micromap ===
1879  class MicromapEXT;
1880 
1881  //=== VK_NV_optical_flow ===
1882  class OpticalFlowSessionNV;
1883 
1884  //=== VK_EXT_shader_object ===
1885  class ShaderEXT;
1886 
1887 #ifndef VULKAN_HPP_NO_SMART_HANDLE
1888  //======================
1889  //=== UNIQUE HANDLEs ===
1890  //======================
1891 
1892  //=== VK_VERSION_1_0 ===
1893  template <typename Dispatch>
1894  class UniqueHandleTraits<Instance, Dispatch>
1895  {
1896  public:
1898  };
1899 
1901 
1902  template <typename Dispatch>
1903  class UniqueHandleTraits<Device, Dispatch>
1904  {
1905  public:
1907  };
1908 
1910 
1911  template <typename Dispatch>
1913  {
1914  public:
1916  };
1917 
1919 
1920  template <typename Dispatch>
1921  class UniqueHandleTraits<Fence, Dispatch>
1922  {
1923  public:
1925  };
1926 
1928 
1929  template <typename Dispatch>
1931  {
1932  public:
1934  };
1935 
1937 
1938  template <typename Dispatch>
1939  class UniqueHandleTraits<Event, Dispatch>
1940  {
1941  public:
1943  };
1944 
1946 
1947  template <typename Dispatch>
1949  {
1950  public:
1952  };
1953 
1955 
1956  template <typename Dispatch>
1957  class UniqueHandleTraits<Buffer, Dispatch>
1958  {
1959  public:
1961  };
1962 
1964 
1965  template <typename Dispatch>
1967  {
1968  public:
1970  };
1971 
1973 
1974  template <typename Dispatch>
1975  class UniqueHandleTraits<Image, Dispatch>
1976  {
1977  public:
1979  };
1980 
1982 
1983  template <typename Dispatch>
1985  {
1986  public:
1988  };
1989 
1991 
1992  template <typename Dispatch>
1994  {
1995  public:
1997  };
1998 
2000 
2001  template <typename Dispatch>
2003  {
2004  public:
2006  };
2007 
2009 
2010  template <typename Dispatch>
2011  class UniqueHandleTraits<Pipeline, Dispatch>
2012  {
2013  public:
2015  };
2016 
2018 
2019  template <typename Dispatch>
2021  {
2022  public:
2024  };
2025 
2027 
2028  template <typename Dispatch>
2029  class UniqueHandleTraits<Sampler, Dispatch>
2030  {
2031  public:
2033  };
2034 
2036 
2037  template <typename Dispatch>
2039  {
2040  public:
2042  };
2043 
2045 
2046  template <typename Dispatch>
2048  {
2049  public:
2051  };
2052 
2054 
2055  template <typename Dispatch>
2057  {
2058  public:
2060  };
2061 
2063 
2064  template <typename Dispatch>
2066  {
2067  public:
2069  };
2070 
2072 
2073  template <typename Dispatch>
2075  {
2076  public:
2078  };
2079 
2081 
2082  template <typename Dispatch>
2084  {
2085  public:
2087  };
2088 
2090 
2091  template <typename Dispatch>
2093  {
2094  public:
2096  };
2097 
2099 
2100  //=== VK_VERSION_1_1 ===
2101  template <typename Dispatch>
2103  {
2104  public:
2106  };
2107 
2110 
2111  template <typename Dispatch>
2113  {
2114  public:
2116  };
2117 
2120 
2121  //=== VK_VERSION_1_3 ===
2122  template <typename Dispatch>
2124  {
2125  public:
2127  };
2128 
2131 
2132  //=== VK_KHR_surface ===
2133  template <typename Dispatch>
2135  {
2136  public:
2138  };
2139 
2141 
2142  //=== VK_KHR_swapchain ===
2143  template <typename Dispatch>
2145  {
2146  public:
2148  };
2149 
2151 
2152  //=== VK_KHR_display ===
2153  template <typename Dispatch>
2155  {
2156  public:
2158  };
2159 
2161 
2162  //=== VK_EXT_debug_report ===
2163  template <typename Dispatch>
2165  {
2166  public:
2168  };
2169 
2171 
2172  //=== VK_KHR_video_queue ===
2173  template <typename Dispatch>
2175  {
2176  public:
2178  };
2179 
2181 
2182  template <typename Dispatch>
2184  {
2185  public:
2187  };
2188 
2190 
2191  //=== VK_NVX_binary_import ===
2192  template <typename Dispatch>
2194  {
2195  public:
2197  };
2198 
2200 
2201  template <typename Dispatch>
2203  {
2204  public:
2206  };
2207 
2209 
2210  //=== VK_EXT_debug_utils ===
2211  template <typename Dispatch>
2213  {
2214  public:
2216  };
2217 
2219 
2220  //=== VK_KHR_acceleration_structure ===
2221  template <typename Dispatch>
2223  {
2224  public:
2226  };
2227 
2229 
2230  //=== VK_EXT_validation_cache ===
2231  template <typename Dispatch>
2233  {
2234  public:
2236  };
2237 
2239 
2240  //=== VK_NV_ray_tracing ===
2241  template <typename Dispatch>
2243  {
2244  public:
2246  };
2247 
2249 
2250  //=== VK_INTEL_performance_query ===
2251  template <typename Dispatch>
2253  {
2254  public:
2256  };
2257 
2259 
2260  //=== VK_KHR_deferred_host_operations ===
2261  template <typename Dispatch>
2263  {
2264  public:
2266  };
2267 
2269 
2270  //=== VK_NV_device_generated_commands ===
2271  template <typename Dispatch>
2273  {
2274  public:
2276  };
2277 
2279 
2280 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2281  //=== VK_NV_cuda_kernel_launch ===
2282  template <typename Dispatch>
2284  {
2285  public:
2287  };
2288 
2290 
2291  template <typename Dispatch>
2293  {
2294  public:
2296  };
2297 
2299 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2300 
2301 # if defined( VK_USE_PLATFORM_FUCHSIA )
2302  //=== VK_FUCHSIA_buffer_collection ===
2303  template <typename Dispatch>
2304  class UniqueHandleTraits<BufferCollectionFUCHSIA, Dispatch>
2305  {
2306  public:
2307  using deleter = ObjectDestroy<Device, Dispatch>;
2308  };
2309 
2310  using UniqueBufferCollectionFUCHSIA = UniqueHandle<BufferCollectionFUCHSIA, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
2311 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2312 
2313  //=== VK_EXT_opacity_micromap ===
2314  template <typename Dispatch>
2316  {
2317  public:
2319  };
2320 
2322 
2323  //=== VK_NV_optical_flow ===
2324  template <typename Dispatch>
2326  {
2327  public:
2329  };
2330 
2332 
2333  //=== VK_EXT_shader_object ===
2334  template <typename Dispatch>
2336  {
2337  public:
2339  };
2340 
2342 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
2343 
2344  //===============
2345  //=== HANDLEs ===
2346  //===============
2347 
2348  template <typename Type>
2350  {
2351  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
2352  };
2353 
2355  {
2356  public:
2359 
2360  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
2362  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
2363 
2364  public:
2366 
2368 
2369  VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {}
2370 
2371 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2372  SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
2373  {
2374  m_surfaceKHR = surfaceKHR;
2375  return *this;
2376  }
2377 #endif
2378 
2380  {
2381  m_surfaceKHR = {};
2382  return *this;
2383  }
2384 
2385 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2386  auto operator<=>( SurfaceKHR const & ) const = default;
2387 #else
2388  bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2389  {
2390  return m_surfaceKHR == rhs.m_surfaceKHR;
2391  }
2392 
2393  bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2394  {
2395  return m_surfaceKHR != rhs.m_surfaceKHR;
2396  }
2397 
2398  bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2399  {
2400  return m_surfaceKHR < rhs.m_surfaceKHR;
2401  }
2402 #endif
2403 
2405  {
2406  return m_surfaceKHR;
2407  }
2408 
2409  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2410  {
2411  return m_surfaceKHR != VK_NULL_HANDLE;
2412  }
2413 
2415  {
2416  return m_surfaceKHR == VK_NULL_HANDLE;
2417  }
2418 
2419  private:
2420  VkSurfaceKHR m_surfaceKHR = {};
2421  };
2422 
2423  template <>
2424  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
2425  {
2426  using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2427  };
2428 
2429  template <>
2430  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
2431  {
2432  using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
2433  };
2434 
2435  template <>
2436  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
2437  {
2438  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2439  };
2440 
2442  {
2443  public:
2446 
2447  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
2449  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
2450 
2451  public:
2453 
2455 
2457  : m_debugReportCallbackEXT( debugReportCallbackEXT )
2458  {
2459  }
2460 
2461 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2462  DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
2463  {
2464  m_debugReportCallbackEXT = debugReportCallbackEXT;
2465  return *this;
2466  }
2467 #endif
2468 
2470  {
2471  m_debugReportCallbackEXT = {};
2472  return *this;
2473  }
2474 
2475 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2476  auto operator<=>( DebugReportCallbackEXT const & ) const = default;
2477 #else
2479  {
2480  return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
2481  }
2482 
2484  {
2485  return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
2486  }
2487 
2489  {
2490  return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
2491  }
2492 #endif
2493 
2495  {
2496  return m_debugReportCallbackEXT;
2497  }
2498 
2499  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2500  {
2501  return m_debugReportCallbackEXT != VK_NULL_HANDLE;
2502  }
2503 
2505  {
2506  return m_debugReportCallbackEXT == VK_NULL_HANDLE;
2507  }
2508 
2509  private:
2510  VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
2511  };
2512 
2513  template <>
2514  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
2515  {
2516  using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2517  };
2518 
2519  template <>
2520  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
2521  {
2522  using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
2523  };
2524 
2525  template <>
2526  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
2527  {
2528  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2529  };
2530 
2532  {
2533  public:
2536 
2537  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
2539  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2540 
2541  public:
2543 
2545 
2547  : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
2548  {
2549  }
2550 
2551 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2552  DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
2553  {
2554  m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
2555  return *this;
2556  }
2557 #endif
2558 
2560  {
2561  m_debugUtilsMessengerEXT = {};
2562  return *this;
2563  }
2564 
2565 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2566  auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
2567 #else
2569  {
2570  return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
2571  }
2572 
2574  {
2575  return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
2576  }
2577 
2579  {
2580  return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
2581  }
2582 #endif
2583 
2585  {
2586  return m_debugUtilsMessengerEXT;
2587  }
2588 
2589  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2590  {
2591  return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
2592  }
2593 
2595  {
2596  return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
2597  }
2598 
2599  private:
2600  VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
2601  };
2602 
2603  template <>
2604  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
2605  {
2606  using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
2607  };
2608 
2609  template <>
2610  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
2611  {
2612  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2613  };
2614 
2616  {
2617  public:
2620 
2621  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
2623  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
2624 
2625  public:
2627 
2629 
2630  VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {}
2631 
2632 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2633  DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
2634  {
2635  m_displayKHR = displayKHR;
2636  return *this;
2637  }
2638 #endif
2639 
2641  {
2642  m_displayKHR = {};
2643  return *this;
2644  }
2645 
2646 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2647  auto operator<=>( DisplayKHR const & ) const = default;
2648 #else
2649  bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2650  {
2651  return m_displayKHR == rhs.m_displayKHR;
2652  }
2653 
2654  bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2655  {
2656  return m_displayKHR != rhs.m_displayKHR;
2657  }
2658 
2659  bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2660  {
2661  return m_displayKHR < rhs.m_displayKHR;
2662  }
2663 #endif
2664 
2666  {
2667  return m_displayKHR;
2668  }
2669 
2670  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2671  {
2672  return m_displayKHR != VK_NULL_HANDLE;
2673  }
2674 
2676  {
2677  return m_displayKHR == VK_NULL_HANDLE;
2678  }
2679 
2680  private:
2681  VkDisplayKHR m_displayKHR = {};
2682  };
2683 
2684  template <>
2685  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
2686  {
2687  using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2688  };
2689 
2690  template <>
2691  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
2692  {
2693  using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
2694  };
2695 
2696  template <>
2697  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
2698  {
2699  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2700  };
2701 
2703  {
2704  public:
2707 
2708  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
2710  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
2711 
2712  public:
2714 
2716 
2717  VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {}
2718 
2719 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2720  SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
2721  {
2722  m_swapchainKHR = swapchainKHR;
2723  return *this;
2724  }
2725 #endif
2726 
2728  {
2729  m_swapchainKHR = {};
2730  return *this;
2731  }
2732 
2733 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2734  auto operator<=>( SwapchainKHR const & ) const = default;
2735 #else
2736  bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2737  {
2738  return m_swapchainKHR == rhs.m_swapchainKHR;
2739  }
2740 
2741  bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2742  {
2743  return m_swapchainKHR != rhs.m_swapchainKHR;
2744  }
2745 
2746  bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2747  {
2748  return m_swapchainKHR < rhs.m_swapchainKHR;
2749  }
2750 #endif
2751 
2753  {
2754  return m_swapchainKHR;
2755  }
2756 
2757  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2758  {
2759  return m_swapchainKHR != VK_NULL_HANDLE;
2760  }
2761 
2763  {
2764  return m_swapchainKHR == VK_NULL_HANDLE;
2765  }
2766 
2767  private:
2768  VkSwapchainKHR m_swapchainKHR = {};
2769  };
2770 
2771  template <>
2772  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
2773  {
2774  using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2775  };
2776 
2777  template <>
2778  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
2779  {
2780  using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
2781  };
2782 
2783  template <>
2784  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
2785  {
2786  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2787  };
2788 
2790  {
2791  public:
2794 
2795  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
2797  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
2798 
2799  public:
2801 
2803 
2804  VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
2805 
2806 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2807  Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
2808  {
2809  m_semaphore = semaphore;
2810  return *this;
2811  }
2812 #endif
2813 
2815  {
2816  m_semaphore = {};
2817  return *this;
2818  }
2819 
2820 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2821  auto operator<=>( Semaphore const & ) const = default;
2822 #else
2823  bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2824  {
2825  return m_semaphore == rhs.m_semaphore;
2826  }
2827 
2828  bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2829  {
2830  return m_semaphore != rhs.m_semaphore;
2831  }
2832 
2833  bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
2834  {
2835  return m_semaphore < rhs.m_semaphore;
2836  }
2837 #endif
2838 
2840  {
2841  return m_semaphore;
2842  }
2843 
2844  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2845  {
2846  return m_semaphore != VK_NULL_HANDLE;
2847  }
2848 
2850  {
2851  return m_semaphore == VK_NULL_HANDLE;
2852  }
2853 
2854  private:
2855  VkSemaphore m_semaphore = {};
2856  };
2857 
2858  template <>
2859  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
2860  {
2861  using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2862  };
2863 
2864  template <>
2865  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
2866  {
2867  using Type = VULKAN_HPP_NAMESPACE::Semaphore;
2868  };
2869 
2870  template <>
2871  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
2872  {
2873  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2874  };
2875 
2876  class Fence
2877  {
2878  public:
2879  using CType = VkFence;
2881 
2882  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
2884  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
2885 
2886  public:
2888 
2890 
2892 
2893 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2894  Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
2895  {
2896  m_fence = fence;
2897  return *this;
2898  }
2899 #endif
2900 
2902  {
2903  m_fence = {};
2904  return *this;
2905  }
2906 
2907 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2908  auto operator<=>( Fence const & ) const = default;
2909 #else
2910  bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2911  {
2912  return m_fence == rhs.m_fence;
2913  }
2914 
2915  bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2916  {
2917  return m_fence != rhs.m_fence;
2918  }
2919 
2920  bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
2921  {
2922  return m_fence < rhs.m_fence;
2923  }
2924 #endif
2925 
2927  {
2928  return m_fence;
2929  }
2930 
2931  explicit operator bool() const VULKAN_HPP_NOEXCEPT
2932  {
2933  return m_fence != VK_NULL_HANDLE;
2934  }
2935 
2937  {
2938  return m_fence == VK_NULL_HANDLE;
2939  }
2940 
2941  private:
2942  VkFence m_fence = {};
2943  };
2944 
2945  template <>
2946  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
2947  {
2948  using Type = VULKAN_HPP_NAMESPACE::Fence;
2949  };
2950 
2951  template <>
2952  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
2953  {
2954  using Type = VULKAN_HPP_NAMESPACE::Fence;
2955  };
2956 
2957  template <>
2958  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
2959  {
2960  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2961  };
2962 
2964  {
2965  public:
2968 
2969  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
2971  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
2972 
2973  public:
2975 
2977 
2979  : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
2980  {
2981  }
2982 
2983 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
2984  PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
2985  {
2986  m_performanceConfigurationINTEL = performanceConfigurationINTEL;
2987  return *this;
2988  }
2989 #endif
2990 
2992  {
2993  m_performanceConfigurationINTEL = {};
2994  return *this;
2995  }
2996 
2997 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2998  auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
2999 #else
3001  {
3002  return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
3003  }
3004 
3006  {
3007  return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
3008  }
3009 
3011  {
3012  return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
3013  }
3014 #endif
3015 
3017  {
3018  return m_performanceConfigurationINTEL;
3019  }
3020 
3021  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3022  {
3023  return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
3024  }
3025 
3027  {
3028  return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
3029  }
3030 
3031  private:
3032  VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
3033  };
3034 
3035  template <>
3036  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
3037  {
3038  using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
3039  };
3040 
3041  template <>
3043  {
3044  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3045  };
3046 
3048  {
3049  public:
3052 
3053  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
3055  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
3056 
3057  public:
3059 
3061 
3062  VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
3063 
3064 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3065  QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
3066  {
3067  m_queryPool = queryPool;
3068  return *this;
3069  }
3070 #endif
3071 
3073  {
3074  m_queryPool = {};
3075  return *this;
3076  }
3077 
3078 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3079  auto operator<=>( QueryPool const & ) const = default;
3080 #else
3081  bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3082  {
3083  return m_queryPool == rhs.m_queryPool;
3084  }
3085 
3086  bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3087  {
3088  return m_queryPool != rhs.m_queryPool;
3089  }
3090 
3091  bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
3092  {
3093  return m_queryPool < rhs.m_queryPool;
3094  }
3095 #endif
3096 
3098  {
3099  return m_queryPool;
3100  }
3101 
3102  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3103  {
3104  return m_queryPool != VK_NULL_HANDLE;
3105  }
3106 
3108  {
3109  return m_queryPool == VK_NULL_HANDLE;
3110  }
3111 
3112  private:
3113  VkQueryPool m_queryPool = {};
3114  };
3115 
3116  template <>
3117  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
3118  {
3119  using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3120  };
3121 
3122  template <>
3123  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
3124  {
3125  using Type = VULKAN_HPP_NAMESPACE::QueryPool;
3126  };
3127 
3128  template <>
3129  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
3130  {
3131  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3132  };
3133 
3134  class Buffer
3135  {
3136  public:
3137  using CType = VkBuffer;
3139 
3140  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
3142  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
3143 
3144  public:
3146 
3148 
3150 
3151 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3152  Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
3153  {
3154  m_buffer = buffer;
3155  return *this;
3156  }
3157 #endif
3158 
3160  {
3161  m_buffer = {};
3162  return *this;
3163  }
3164 
3165 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3166  auto operator<=>( Buffer const & ) const = default;
3167 #else
3168  bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3169  {
3170  return m_buffer == rhs.m_buffer;
3171  }
3172 
3173  bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3174  {
3175  return m_buffer != rhs.m_buffer;
3176  }
3177 
3178  bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
3179  {
3180  return m_buffer < rhs.m_buffer;
3181  }
3182 #endif
3183 
3185  {
3186  return m_buffer;
3187  }
3188 
3189  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3190  {
3191  return m_buffer != VK_NULL_HANDLE;
3192  }
3193 
3195  {
3196  return m_buffer == VK_NULL_HANDLE;
3197  }
3198 
3199  private:
3200  VkBuffer m_buffer = {};
3201  };
3202 
3203  template <>
3204  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
3205  {
3206  using Type = VULKAN_HPP_NAMESPACE::Buffer;
3207  };
3208 
3209  template <>
3210  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
3211  {
3212  using Type = VULKAN_HPP_NAMESPACE::Buffer;
3213  };
3214 
3215  template <>
3216  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
3217  {
3218  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3219  };
3220 
3222  {
3223  public:
3226 
3227  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
3229  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
3230 
3231  public:
3233 
3235 
3236  VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {}
3237 
3238 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3239  PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
3240  {
3241  m_pipelineLayout = pipelineLayout;
3242  return *this;
3243  }
3244 #endif
3245 
3247  {
3248  m_pipelineLayout = {};
3249  return *this;
3250  }
3251 
3252 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3253  auto operator<=>( PipelineLayout const & ) const = default;
3254 #else
3256  {
3257  return m_pipelineLayout == rhs.m_pipelineLayout;
3258  }
3259 
3261  {
3262  return m_pipelineLayout != rhs.m_pipelineLayout;
3263  }
3264 
3266  {
3267  return m_pipelineLayout < rhs.m_pipelineLayout;
3268  }
3269 #endif
3270 
3272  {
3273  return m_pipelineLayout;
3274  }
3275 
3276  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3277  {
3278  return m_pipelineLayout != VK_NULL_HANDLE;
3279  }
3280 
3282  {
3283  return m_pipelineLayout == VK_NULL_HANDLE;
3284  }
3285 
3286  private:
3287  VkPipelineLayout m_pipelineLayout = {};
3288  };
3289 
3290  template <>
3291  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
3292  {
3293  using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3294  };
3295 
3296  template <>
3297  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
3298  {
3299  using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
3300  };
3301 
3302  template <>
3303  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
3304  {
3305  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3306  };
3307 
3309  {
3310  public:
3313 
3314  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
3316  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
3317 
3318  public:
3320 
3322 
3323  VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {}
3324 
3325 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3326  DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
3327  {
3328  m_descriptorSet = descriptorSet;
3329  return *this;
3330  }
3331 #endif
3332 
3334  {
3335  m_descriptorSet = {};
3336  return *this;
3337  }
3338 
3339 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3340  auto operator<=>( DescriptorSet const & ) const = default;
3341 #else
3343  {
3344  return m_descriptorSet == rhs.m_descriptorSet;
3345  }
3346 
3348  {
3349  return m_descriptorSet != rhs.m_descriptorSet;
3350  }
3351 
3352  bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
3353  {
3354  return m_descriptorSet < rhs.m_descriptorSet;
3355  }
3356 #endif
3357 
3359  {
3360  return m_descriptorSet;
3361  }
3362 
3363  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3364  {
3365  return m_descriptorSet != VK_NULL_HANDLE;
3366  }
3367 
3369  {
3370  return m_descriptorSet == VK_NULL_HANDLE;
3371  }
3372 
3373  private:
3374  VkDescriptorSet m_descriptorSet = {};
3375  };
3376 
3377  template <>
3378  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
3379  {
3380  using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3381  };
3382 
3383  template <>
3384  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
3385  {
3386  using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
3387  };
3388 
3389  template <>
3390  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
3391  {
3392  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3393  };
3394 
3396  {
3397  public:
3400 
3401  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
3403  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
3404 
3405  public:
3407 
3409 
3410  VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
3411 
3412 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3413  ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
3414  {
3415  m_imageView = imageView;
3416  return *this;
3417  }
3418 #endif
3419 
3421  {
3422  m_imageView = {};
3423  return *this;
3424  }
3425 
3426 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3427  auto operator<=>( ImageView const & ) const = default;
3428 #else
3429  bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3430  {
3431  return m_imageView == rhs.m_imageView;
3432  }
3433 
3434  bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3435  {
3436  return m_imageView != rhs.m_imageView;
3437  }
3438 
3439  bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
3440  {
3441  return m_imageView < rhs.m_imageView;
3442  }
3443 #endif
3444 
3446  {
3447  return m_imageView;
3448  }
3449 
3450  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3451  {
3452  return m_imageView != VK_NULL_HANDLE;
3453  }
3454 
3456  {
3457  return m_imageView == VK_NULL_HANDLE;
3458  }
3459 
3460  private:
3461  VkImageView m_imageView = {};
3462  };
3463 
3464  template <>
3465  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
3466  {
3467  using Type = VULKAN_HPP_NAMESPACE::ImageView;
3468  };
3469 
3470  template <>
3471  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
3472  {
3473  using Type = VULKAN_HPP_NAMESPACE::ImageView;
3474  };
3475 
3476  template <>
3477  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
3478  {
3479  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3480  };
3481 
3482  class Pipeline
3483  {
3484  public:
3487 
3488  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
3490  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
3491 
3492  public:
3494 
3496 
3498 
3499 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3500  Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
3501  {
3502  m_pipeline = pipeline;
3503  return *this;
3504  }
3505 #endif
3506 
3508  {
3509  m_pipeline = {};
3510  return *this;
3511  }
3512 
3513 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3514  auto operator<=>( Pipeline const & ) const = default;
3515 #else
3516  bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3517  {
3518  return m_pipeline == rhs.m_pipeline;
3519  }
3520 
3521  bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3522  {
3523  return m_pipeline != rhs.m_pipeline;
3524  }
3525 
3526  bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
3527  {
3528  return m_pipeline < rhs.m_pipeline;
3529  }
3530 #endif
3531 
3533  {
3534  return m_pipeline;
3535  }
3536 
3537  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3538  {
3539  return m_pipeline != VK_NULL_HANDLE;
3540  }
3541 
3543  {
3544  return m_pipeline == VK_NULL_HANDLE;
3545  }
3546 
3547  private:
3548  VkPipeline m_pipeline = {};
3549  };
3550 
3551  template <>
3552  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
3553  {
3554  using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3555  };
3556 
3557  template <>
3558  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
3559  {
3560  using Type = VULKAN_HPP_NAMESPACE::Pipeline;
3561  };
3562 
3563  template <>
3564  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
3565  {
3566  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3567  };
3568 
3570  {
3571  public:
3574 
3575  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;
3577  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3578 
3579  public:
3581 
3583 
3584  VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {}
3585 
3586 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3587  ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT
3588  {
3589  m_shaderEXT = shaderEXT;
3590  return *this;
3591  }
3592 #endif
3593 
3595  {
3596  m_shaderEXT = {};
3597  return *this;
3598  }
3599 
3600 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3601  auto operator<=>( ShaderEXT const & ) const = default;
3602 #else
3603  bool operator==( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3604  {
3605  return m_shaderEXT == rhs.m_shaderEXT;
3606  }
3607 
3608  bool operator!=( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3609  {
3610  return m_shaderEXT != rhs.m_shaderEXT;
3611  }
3612 
3613  bool operator<( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
3614  {
3615  return m_shaderEXT < rhs.m_shaderEXT;
3616  }
3617 #endif
3618 
3620  {
3621  return m_shaderEXT;
3622  }
3623 
3624  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3625  {
3626  return m_shaderEXT != VK_NULL_HANDLE;
3627  }
3628 
3630  {
3631  return m_shaderEXT == VK_NULL_HANDLE;
3632  }
3633 
3634  private:
3635  VkShaderEXT m_shaderEXT = {};
3636  };
3637 
3638  template <>
3639  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT>
3640  {
3641  using Type = VULKAN_HPP_NAMESPACE::ShaderEXT;
3642  };
3643 
3644  template <>
3645  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderEXT>
3646  {
3647  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3648  };
3649 
3650  class Image
3651  {
3652  public:
3653  using CType = VkImage;
3655 
3656  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
3658  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
3659 
3660  public:
3662 
3664 
3666 
3667 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3668  Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
3669  {
3670  m_image = image;
3671  return *this;
3672  }
3673 #endif
3674 
3676  {
3677  m_image = {};
3678  return *this;
3679  }
3680 
3681 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3682  auto operator<=>( Image const & ) const = default;
3683 #else
3684  bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3685  {
3686  return m_image == rhs.m_image;
3687  }
3688 
3689  bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3690  {
3691  return m_image != rhs.m_image;
3692  }
3693 
3694  bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
3695  {
3696  return m_image < rhs.m_image;
3697  }
3698 #endif
3699 
3701  {
3702  return m_image;
3703  }
3704 
3705  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3706  {
3707  return m_image != VK_NULL_HANDLE;
3708  }
3709 
3711  {
3712  return m_image == VK_NULL_HANDLE;
3713  }
3714 
3715  private:
3716  VkImage m_image = {};
3717  };
3718 
3719  template <>
3720  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
3721  {
3722  using Type = VULKAN_HPP_NAMESPACE::Image;
3723  };
3724 
3725  template <>
3726  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
3727  {
3728  using Type = VULKAN_HPP_NAMESPACE::Image;
3729  };
3730 
3731  template <>
3732  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
3733  {
3734  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3735  };
3736 
3738  {
3739  public:
3742 
3743  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
3745  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
3746 
3747  public:
3749 
3751 
3753  : m_accelerationStructureNV( accelerationStructureNV )
3754  {
3755  }
3756 
3757 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3758  AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
3759  {
3760  m_accelerationStructureNV = accelerationStructureNV;
3761  return *this;
3762  }
3763 #endif
3764 
3766  {
3767  m_accelerationStructureNV = {};
3768  return *this;
3769  }
3770 
3771 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3772  auto operator<=>( AccelerationStructureNV const & ) const = default;
3773 #else
3775  {
3776  return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
3777  }
3778 
3780  {
3781  return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
3782  }
3783 
3785  {
3786  return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
3787  }
3788 #endif
3789 
3791  {
3792  return m_accelerationStructureNV;
3793  }
3794 
3795  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3796  {
3797  return m_accelerationStructureNV != VK_NULL_HANDLE;
3798  }
3799 
3801  {
3802  return m_accelerationStructureNV == VK_NULL_HANDLE;
3803  }
3804 
3805  private:
3806  VkAccelerationStructureNV m_accelerationStructureNV = {};
3807  };
3808 
3809  template <>
3810  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
3811  {
3812  using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
3813  };
3814 
3815  template <>
3816  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
3817  {
3818  using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
3819  };
3820 
3821  template <>
3822  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
3823  {
3824  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3825  };
3826 
3828  {
3829  public:
3832 
3833  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;
3835  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
3836 
3837  public:
3839 
3841 
3843  : m_opticalFlowSessionNV( opticalFlowSessionNV )
3844  {
3845  }
3846 
3847 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3848  OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT
3849  {
3850  m_opticalFlowSessionNV = opticalFlowSessionNV;
3851  return *this;
3852  }
3853 #endif
3854 
3856  {
3857  m_opticalFlowSessionNV = {};
3858  return *this;
3859  }
3860 
3861 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3862  auto operator<=>( OpticalFlowSessionNV const & ) const = default;
3863 #else
3865  {
3866  return m_opticalFlowSessionNV == rhs.m_opticalFlowSessionNV;
3867  }
3868 
3870  {
3871  return m_opticalFlowSessionNV != rhs.m_opticalFlowSessionNV;
3872  }
3873 
3875  {
3876  return m_opticalFlowSessionNV < rhs.m_opticalFlowSessionNV;
3877  }
3878 #endif
3879 
3881  {
3882  return m_opticalFlowSessionNV;
3883  }
3884 
3885  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3886  {
3887  return m_opticalFlowSessionNV != VK_NULL_HANDLE;
3888  }
3889 
3891  {
3892  return m_opticalFlowSessionNV == VK_NULL_HANDLE;
3893  }
3894 
3895  private:
3896  VkOpticalFlowSessionNV m_opticalFlowSessionNV = {};
3897  };
3898 
3899  template <>
3900  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV>
3901  {
3902  using Type = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
3903  };
3904 
3905  template <>
3906  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV>
3907  {
3908  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3909  };
3910 
3912  {
3913  public:
3916 
3917  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
3919  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
3920 
3921  public:
3923 
3925 
3927  : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
3928  {
3929  }
3930 
3931 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
3932  DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
3933  {
3934  m_descriptorUpdateTemplate = descriptorUpdateTemplate;
3935  return *this;
3936  }
3937 #endif
3938 
3940  {
3941  m_descriptorUpdateTemplate = {};
3942  return *this;
3943  }
3944 
3945 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
3946  auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
3947 #else
3949  {
3950  return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
3951  }
3952 
3954  {
3955  return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
3956  }
3957 
3959  {
3960  return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
3961  }
3962 #endif
3963 
3965  {
3966  return m_descriptorUpdateTemplate;
3967  }
3968 
3969  explicit operator bool() const VULKAN_HPP_NOEXCEPT
3970  {
3971  return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
3972  }
3973 
3975  {
3976  return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
3977  }
3978 
3979  private:
3980  VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
3981  };
3982 
3983  template <>
3984  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
3985  {
3986  using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
3987  };
3988 
3989  template <>
3990  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
3991  {
3992  using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
3993  };
3994 
3995  template <>
3996  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
3997  {
3998  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
3999  };
4000 
4002 
4003  class Event
4004  {
4005  public:
4006  using CType = VkEvent;
4008 
4009  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
4011  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
4012 
4013  public:
4015 
4017 
4019 
4020 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
4021  Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
4022  {
4023  m_event = event;
4024  return *this;
4025  }
4026 #endif
4027 
4029  {
4030  m_event = {};
4031  return *this;
4032  }
4033 
4034 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4035  auto operator<=>( Event const & ) const = default;
4036 #else
4037  bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4038  {
4039  return m_event == rhs.m_event;
4040  }
4041 
4042  bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4043  {
4044  return m_event != rhs.m_event;
4045  }
4046 
4047  bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
4048  {
4049  return m_event < rhs.m_event;
4050  }
4051 #endif
4052 
4054  {
4055  return m_event;
4056  }
4057 
4058  explicit operator bool() const VULKAN_HPP_NOEXCEPT
4059  {
4060  return m_event != VK_NULL_HANDLE;
4061  }
4062 
4064  {
4065  return m_event == VK_NULL_HANDLE;
4066  }
4067 
4068  private:
4069  VkEvent m_event = {};
4070  };
4071 
4072  template <>
4073  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
4074  {
4075  using Type = VULKAN_HPP_NAMESPACE::Event;
4076  };
4077 
4078  template <>
4079  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
4080  {
4081  using Type = VULKAN_HPP_NAMESPACE::Event;
4082  };
4083 
4084  template <>
4085  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
4086  {
4087  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4088  };
4089 
4091  {
4092  public:
4095 
4096  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
4098  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
4099 
4100  public:
4102 
4104 
4106  : m_accelerationStructureKHR( accelerationStructureKHR )
4107  {
4108  }
4109 
4110 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
4111  AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
4112  {
4113  m_accelerationStructureKHR = accelerationStructureKHR;
4114  return *this;
4115  }
4116 #endif
4117 
4119  {
4120  m_accelerationStructureKHR = {};
4121  return *this;
4122  }
4123 
4124 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4125  auto operator<=>( AccelerationStructureKHR const & ) const = default;
4126 #else
4128  {
4129  return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
4130  }
4131 
4133  {
4134  return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
4135  }
4136 
4138  {
4139  return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
4140  }
4141 #endif
4142 
4144  {
4145  return m_accelerationStructureKHR;
4146  }
4147 
4148  explicit operator bool() const VULKAN_HPP_NOEXCEPT
4149  {
4150  return m_accelerationStructureKHR != VK_NULL_HANDLE;
4151  }
4152 
4154  {
4155  return m_accelerationStructureKHR == VK_NULL_HANDLE;
4156  }
4157 
4158  private:
4159  VkAccelerationStructureKHR m_accelerationStructureKHR = {};
4160  };
4161 
4162  template <>
4163  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
4164  {
4165  using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4166  };
4167 
4168  template <>
4169  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
4170  {
4171  using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
4172  };
4173 
4174  template <>
4175  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
4176  {
4177  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4178  };
4179 
4181  {
4182  public:
4185 
4186  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;
4188  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4189 
4190  public:
4192 
4194 
4195  VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {}
4196 
4197 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
4198  MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT
4199  {
4200  m_micromapEXT = micromapEXT;
4201  return *this;
4202  }
4203 #endif
4204 
4206  {
4207  m_micromapEXT = {};
4208  return *this;
4209  }
4210 
4211 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4212  auto operator<=>( MicromapEXT const & ) const = default;
4213 #else
4214  bool operator==( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4215  {
4216  return m_micromapEXT == rhs.m_micromapEXT;
4217  }
4218 
4219  bool operator!=( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4220  {
4221  return m_micromapEXT != rhs.m_micromapEXT;
4222  }
4223 
4224  bool operator<( MicromapEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
4225  {
4226  return m_micromapEXT < rhs.m_micromapEXT;
4227  }
4228 #endif
4229 
4231  {
4232  return m_micromapEXT;
4233  }
4234 
4235  explicit operator bool() const VULKAN_HPP_NOEXCEPT
4236  {
4237  return m_micromapEXT != VK_NULL_HANDLE;
4238  }
4239 
4241  {
4242  return m_micromapEXT == VK_NULL_HANDLE;
4243  }
4244 
4245  private:
4246  VkMicromapEXT m_micromapEXT = {};
4247  };
4248 
4249  template <>
4250  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT>
4251  {
4252  using Type = VULKAN_HPP_NAMESPACE::MicromapEXT;
4253  };
4254 
4255  template <>
4256  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::MicromapEXT>
4257  {
4258  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4259  };
4260 
4262  {
4263  public:
4266 
4267  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
4269  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
4270 
4271  public:
4273 
4275 
4276  CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {}
4277 
4279  {
4280  m_commandBuffer = commandBuffer;
4281  return *this;
4282  }
4283 
4285  {
4286  m_commandBuffer = {};
4287  return *this;
4288  }
4289 
4290 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4291  auto operator<=>( CommandBuffer const & ) const = default;
4292 #else
4294  {
4295  return m_commandBuffer == rhs.m_commandBuffer;
4296  }
4297 
4299  {
4300  return m_commandBuffer != rhs.m_commandBuffer;
4301  }
4302 
4303  bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
4304  {
4305  return m_commandBuffer < rhs.m_commandBuffer;
4306  }
4307 #endif
4308 
4309  //=== VK_VERSION_1_0 ===
4310 
4311  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4312  VULKAN_HPP_NODISCARD Result begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
4314 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4315  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4316  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo,
4317  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4318 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4319 
4320 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4321  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4323 #else
4324  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4326 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4327 
4328 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
4329  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4332 #else
4333  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4335  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4336 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4337 
4338  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4340  VULKAN_HPP_NAMESPACE::Pipeline pipeline,
4342 
4343  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4344  void setViewport( uint32_t firstViewport,
4345  uint32_t viewportCount,
4346  const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4348 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4349  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4350  void setViewport( uint32_t firstViewport,
4351  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
4353 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4354 
4355  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4356  void setScissor( uint32_t firstScissor,
4357  uint32_t scissorCount,
4358  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4361  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4362  void setScissor( uint32_t firstScissor,
4363  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
4365 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4366 
4367  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4368  void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4369 
4370  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4371  void setDepthBias( float depthBiasConstantFactor,
4372  float depthBiasClamp,
4373  float depthBiasSlopeFactor,
4375 
4376  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4377  void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4378 
4379  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4380  void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4381 
4382  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4384  uint32_t compareMask,
4386 
4387  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4389  uint32_t writeMask,
4391 
4392  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4394  uint32_t reference,
4396 
4397  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4399  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
4400  uint32_t firstSet,
4401  uint32_t descriptorSetCount,
4402  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
4403  uint32_t dynamicOffsetCount,
4404  const uint32_t * pDynamicOffsets,
4406 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4407  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4409  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
4410  uint32_t firstSet,
4411  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
4412  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets,
4414 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4415 
4416  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4417  void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer,
4421 
4422  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4423  void bindVertexBuffers( uint32_t firstBinding,
4424  uint32_t bindingCount,
4425  const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
4426  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4428 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4429  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4430  void bindVertexBuffers( uint32_t firstBinding,
4431  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
4432  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
4434 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4435 
4436  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4437  void draw( uint32_t vertexCount,
4438  uint32_t instanceCount,
4439  uint32_t firstVertex,
4440  uint32_t firstInstance,
4442 
4443  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4444  void drawIndexed( uint32_t indexCount,
4445  uint32_t instanceCount,
4446  uint32_t firstIndex,
4447  int32_t vertexOffset,
4448  uint32_t firstInstance,
4450 
4451  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4452  void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
4454  uint32_t drawCount,
4455  uint32_t stride,
4457 
4458  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4459  void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
4461  uint32_t drawCount,
4462  uint32_t stride,
4464 
4465  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4466  void dispatch( uint32_t groupCountX,
4467  uint32_t groupCountY,
4468  uint32_t groupCountZ,
4470 
4471  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4472  void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
4475 
4476  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4477  void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
4478  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4479  uint32_t regionCount,
4480  const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
4482 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4483  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4484  void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
4485  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4486  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
4488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4489 
4490  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4491  void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
4492  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
4493  VULKAN_HPP_NAMESPACE::Image dstImage,
4494  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
4495  uint32_t regionCount,
4496  const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
4498 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4499  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4500  void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
4501  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
4502  VULKAN_HPP_NAMESPACE::Image dstImage,
4503  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
4504  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
4506 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4507 
4508  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4509  void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
4510  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
4511  VULKAN_HPP_NAMESPACE::Image dstImage,
4512  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
4513  uint32_t regionCount,
4514  const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
4517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4519  void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
4520  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
4521  VULKAN_HPP_NAMESPACE::Image dstImage,
4522  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
4523  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
4526 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4527 
4528  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4529  void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
4530  VULKAN_HPP_NAMESPACE::Image dstImage,
4531  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
4532  uint32_t regionCount,
4533  const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
4535 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4536  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4537  void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
4538  VULKAN_HPP_NAMESPACE::Image dstImage,
4539  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
4540  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
4542 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4543 
4544  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4545  void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage,
4546  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
4547  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4548  uint32_t regionCount,
4549  const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
4551 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4552  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4553  void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage,
4554  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
4555  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4556  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
4558 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4559 
4560  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4561  void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4564  const void * pData,
4566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4567  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4568  void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4570  VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data,
4572 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4573 
4574  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4575  void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4578  uint32_t data,
4580 
4581  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4582  void clearColorImage( VULKAN_HPP_NAMESPACE::Image image,
4584  const VULKAN_HPP_NAMESPACE::ClearColorValue * pColor,
4585  uint32_t rangeCount,
4586  const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
4588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4589  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4590  void clearColorImage( VULKAN_HPP_NAMESPACE::Image image,
4592  const VULKAN_HPP_NAMESPACE::ClearColorValue & color,
4593  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
4595 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4596 
4597  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4598  void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image,
4600  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
4601  uint32_t rangeCount,
4602  const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
4604 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4605  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4606  void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image,
4608  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil,
4609  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
4611 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4612 
4613  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4614  void clearAttachments( uint32_t attachmentCount,
4615  const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
4616  uint32_t rectCount,
4617  const VULKAN_HPP_NAMESPACE::ClearRect * pRects,
4619 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4620  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4621  void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
4622  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects,
4624 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4625 
4626  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4627  void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage,
4628  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
4629  VULKAN_HPP_NAMESPACE::Image dstImage,
4630  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
4631  uint32_t regionCount,
4632  const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
4634 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4635  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4636  void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage,
4637  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
4638  VULKAN_HPP_NAMESPACE::Image dstImage,
4639  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
4640  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
4642 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4643 
4644  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4645  void setEvent( VULKAN_HPP_NAMESPACE::Event event,
4648 
4649  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4650  void resetEvent( VULKAN_HPP_NAMESPACE::Event event,
4653 
4654  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4655  void waitEvents( uint32_t eventCount,
4656  const VULKAN_HPP_NAMESPACE::Event * pEvents,
4659  uint32_t memoryBarrierCount,
4660  const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers,
4661  uint32_t bufferMemoryBarrierCount,
4662  const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
4663  uint32_t imageMemoryBarrierCount,
4664  const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers,
4666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4667  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4668  void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
4671  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,
4672  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
4673  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers,
4675 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4676 
4677  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4680  VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
4681  uint32_t memoryBarrierCount,
4682  const VULKAN_HPP_NAMESPACE::MemoryBarrier * pMemoryBarriers,
4683  uint32_t bufferMemoryBarrierCount,
4684  const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
4685  uint32_t imageMemoryBarrierCount,
4686  const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier * pImageMemoryBarriers,
4688 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4689  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4692  VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
4693  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,
4694  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
4695  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers,
4697 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4698 
4699  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4700  void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
4701  uint32_t query,
4704 
4705  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4706  void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
4707  uint32_t query,
4709 
4710  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4711  void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
4712  uint32_t firstQuery,
4713  uint32_t queryCount,
4715 
4716  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4718  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
4719  uint32_t query,
4721 
4722  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4723  void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
4724  uint32_t firstQuery,
4725  uint32_t queryCount,
4726  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
4731 
4732  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4733  void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
4735  uint32_t offset,
4736  uint32_t size,
4737  const void * pValues,
4739 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4740  template <typename ValuesType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4741  void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
4743  uint32_t offset,
4744  VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values,
4746 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4747 
4748  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4749  void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
4752 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4753  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4754  void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
4757 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4758 
4759  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4761 
4762  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4764 
4765  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4766  void executeCommands( uint32_t commandBufferCount,
4767  const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
4769 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4770  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4771  void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
4773 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4774 
4775  //=== VK_VERSION_1_1 ===
4776 
4777  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4778  void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4779 
4780  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4781  void dispatchBase( uint32_t baseGroupX,
4782  uint32_t baseGroupY,
4783  uint32_t baseGroupZ,
4784  uint32_t groupCountX,
4785  uint32_t groupCountY,
4786  uint32_t groupCountZ,
4788 
4789  //=== VK_VERSION_1_2 ===
4790 
4791  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4792  void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
4794  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
4795  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4796  uint32_t maxDrawCount,
4797  uint32_t stride,
4799 
4800  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4801  void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
4803  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
4804  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
4805  uint32_t maxDrawCount,
4806  uint32_t stride,
4808 
4809  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4810  void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
4811  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
4813 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4814  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4815  void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
4816  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
4818 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4819 
4820  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4821  void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
4822  const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
4824 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4825  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4826  void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
4827  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
4829 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4830 
4831  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4832  void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
4834 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4835  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4836  void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
4838 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4839 
4840  //=== VK_VERSION_1_3 ===
4841 
4842  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4843  void setEvent2( VULKAN_HPP_NAMESPACE::Event event,
4844  const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
4846 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4847  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4848  void setEvent2( VULKAN_HPP_NAMESPACE::Event event,
4849  const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
4851 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4852 
4853  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4854  void resetEvent2( VULKAN_HPP_NAMESPACE::Event event,
4857 
4858  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4859  void waitEvents2( uint32_t eventCount,
4860  const VULKAN_HPP_NAMESPACE::Event * pEvents,
4861  const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
4863 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4864  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4865  void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
4866  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,
4868 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4869 
4870  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4871  void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
4873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4874  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4875  void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
4877 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4878 
4879  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4881  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
4882  uint32_t query,
4884 
4885  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4886  void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
4888 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4889  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4890  void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
4892 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4893 
4894  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4895  void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
4897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4898  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4899  void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
4901 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4902 
4903  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4904  void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
4906 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4907  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4908  void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
4910 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4911 
4912  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4913  void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
4915 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4916  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4917  void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
4919 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4920 
4921  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4922  void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
4924 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4925  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4926  void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
4928 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4929 
4930  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4931  void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
4933 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4934  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4935  void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
4937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4938 
4939  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4940  void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
4942 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4943  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4944  void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
4946 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4947 
4948  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4950 
4951  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4953 
4954  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4956 
4957  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4960 
4961  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4962  void setViewportWithCount( uint32_t viewportCount,
4963  const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4965 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4966  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4967  void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
4969 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4970 
4971  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4972  void setScissorWithCount( uint32_t scissorCount,
4973  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4975 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4976  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4977  void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
4979 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4980 
4981  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4982  void bindVertexBuffers2( uint32_t firstBinding,
4983  uint32_t bindingCount,
4984  const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
4985  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4986  const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
4987  const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
4989 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4990  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4992  uint32_t firstBinding,
4993  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
4994  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
4995  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4996  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4998 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
4999 
5000  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5003 
5004  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5007 
5008  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5011 
5012  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5015 
5016  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5019 
5020  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5024  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
5027 
5028  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5031 
5032  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5035 
5036  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5039 
5040  //=== VK_EXT_debug_marker ===
5041 
5042  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5043  void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
5045 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5046  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5047  void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
5049 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5050 
5051  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5053 
5054  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5055  void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
5057 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5058  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5059  void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo,
5061 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5062 
5063  //=== VK_KHR_video_queue ===
5064 
5065  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5066  void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
5068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5069  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5070  void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo,
5072 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5073 
5074  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5075  void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
5077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5078  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5079  void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo,
5081 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5082 
5083  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5084  void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
5086 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5087  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5088  void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo,
5090 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5091 
5092  //=== VK_KHR_video_decode_queue ===
5093 
5094  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5095  void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pDecodeInfo,
5097 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5098  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5099  void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo,
5101 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5102 
5103  //=== VK_EXT_transform_feedback ===
5104 
5105  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5106  void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
5107  uint32_t bindingCount,
5108  const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
5109  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5110  const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
5112 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5113  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5114  void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
5115  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
5116  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5117  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes
5120 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5121 
5122  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5123  void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
5124  uint32_t counterBufferCount,
5125  const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers,
5126  const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
5128 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5129  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5130  void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
5131  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5132  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5135 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5136 
5137  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5138  void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
5139  uint32_t counterBufferCount,
5140  const VULKAN_HPP_NAMESPACE::Buffer * pCounterBuffers,
5141  const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
5143 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5144  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5145  void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
5146  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5147  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5150 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5151 
5152  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5153  void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5154  uint32_t query,
5156  uint32_t index,
5158 
5159  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5160  void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5161  uint32_t query,
5162  uint32_t index,
5164 
5165  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5166  void drawIndirectByteCountEXT( uint32_t instanceCount,
5167  uint32_t firstInstance,
5168  VULKAN_HPP_NAMESPACE::Buffer counterBuffer,
5169  VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
5170  uint32_t counterOffset,
5171  uint32_t vertexStride,
5173 
5174  //=== VK_NVX_binary_import ===
5175 
5176  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5177  void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
5179 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5180  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5181  void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo,
5183 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5184 
5185  //=== VK_AMD_draw_indirect_count ===
5186 
5187  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5188  void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
5190  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5191  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5192  uint32_t maxDrawCount,
5193  uint32_t stride,
5195 
5196  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5197  void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
5199  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5200  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5201  uint32_t maxDrawCount,
5202  uint32_t stride,
5204 
5205  //=== VK_KHR_dynamic_rendering ===
5206 
5207  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5208  void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
5210 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5211  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5212  void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
5214 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5215 
5216  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5218 
5219  //=== VK_KHR_device_group ===
5220 
5221  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5222  void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5223 
5224  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5225  void dispatchBaseKHR( uint32_t baseGroupX,
5226  uint32_t baseGroupY,
5227  uint32_t baseGroupZ,
5228  uint32_t groupCountX,
5229  uint32_t groupCountY,
5230  uint32_t groupCountZ,
5232 
5233  //=== VK_KHR_push_descriptor ===
5234 
5235  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5237  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5238  uint32_t set,
5239  uint32_t descriptorWriteCount,
5240  const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
5242 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5243  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5245  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5246  uint32_t set,
5247  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
5249 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5250 
5251  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5252  void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5253  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5254  uint32_t set,
5255  const void * pData,
5257 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5258  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5259  void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5260  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5261  uint32_t set,
5262  DataType const & data,
5264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5265 
5266  //=== VK_EXT_conditional_rendering ===
5267 
5268  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5269  void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
5271 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5272  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5273  void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
5275 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5276 
5277  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5279 
5280  //=== VK_NV_clip_space_w_scaling ===
5281 
5282  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5283  void setViewportWScalingNV( uint32_t firstViewport,
5284  uint32_t viewportCount,
5285  const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
5287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5288  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5289  void setViewportWScalingNV( uint32_t firstViewport,
5290  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
5292 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5293 
5294  //=== VK_EXT_discard_rectangles ===
5295 
5296  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5297  void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
5298  uint32_t discardRectangleCount,
5299  const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
5301 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5302  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5303  void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
5304  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
5306 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5307 
5308  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5311 
5312  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5315 
5316  //=== VK_KHR_create_renderpass2 ===
5317 
5318  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5319  void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
5320  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
5322 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5323  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5324  void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5325  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5327 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5328 
5329  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5330  void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
5331  const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
5333 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5334  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5335  void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5336  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
5338 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5339 
5340  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5341  void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
5343 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5344  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5345  void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo,
5347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5348 
5349  //=== VK_EXT_debug_utils ===
5350 
5351  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5352  void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
5354 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5355  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5356  void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
5358 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5359 
5360  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5362 
5363  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5364  void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
5366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5367  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5368  void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
5370 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5371 
5372 #if defined( VK_ENABLE_BETA_EXTENSIONS )
5373  //=== VK_AMDX_shader_enqueue ===
5374 
5375  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5378 
5379  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5381  const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,
5383 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5384  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5386  const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,
5388 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5389 
5390  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5392  const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX * pCountInfo,
5394 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5395  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5397  const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo,
5399 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5400 
5401  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5405 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
5406 
5407  //=== VK_EXT_sample_locations ===
5408 
5409  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5410  void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
5412 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5413  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5414  void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo,
5416 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5417 
5418  //=== VK_KHR_acceleration_structure ===
5419 
5420  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5421  void buildAccelerationStructuresKHR( uint32_t infoCount,
5422  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
5423  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
5425 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5426  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5428  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
5429  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
5431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5432 
5433  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5434  void buildAccelerationStructuresIndirectKHR( uint32_t infoCount,
5435  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
5436  const VULKAN_HPP_NAMESPACE::DeviceAddress * pIndirectDeviceAddresses,
5437  const uint32_t * pIndirectStrides,
5438  const uint32_t * const * ppMaxPrimitiveCounts,
5440 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5441  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5443  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
5444  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,
5445  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides,
5446  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts,
5448 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5449 
5450  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5451  void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
5453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5454  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5455  void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
5457 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5458 
5459  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5460  void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
5462 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5463  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5464  void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
5466 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5467 
5468  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5469  void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
5471 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5472  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5473  void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
5475 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5476 
5477  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5478  void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
5479  const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
5481  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5482  uint32_t firstQuery,
5484 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5485  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5487  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
5489  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5490  uint32_t firstQuery,
5492 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5493 
5494  //=== VK_KHR_ray_tracing_pipeline ===
5495 
5496  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5497  void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5498  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5499  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5500  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5501  uint32_t width,
5502  uint32_t height,
5503  uint32_t depth,
5505 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5506  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5507  void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5508  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5509  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5510  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5511  uint32_t width,
5512  uint32_t height,
5513  uint32_t depth,
5515 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5516 
5517  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5518  void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5519  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5520  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5521  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5522  VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
5524 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5525  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5526  void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5527  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5528  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5529  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5530  VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress,
5532 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5533 
5534  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5535  void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5536 
5537  //=== VK_NV_shading_rate_image ===
5538 
5539  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5540  void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView,
5543 
5544  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5545  void setViewportShadingRatePaletteNV( uint32_t firstViewport,
5546  uint32_t viewportCount,
5547  const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
5549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5550  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5551  void setViewportShadingRatePaletteNV( uint32_t firstViewport,
5552  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
5554 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5555 
5556  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5558  uint32_t customSampleOrderCount,
5559  const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
5561 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5562  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5564  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
5566 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5567 
5568  //=== VK_NV_ray_tracing ===
5569 
5570  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5571  void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
5572  VULKAN_HPP_NAMESPACE::Buffer instanceData,
5573  VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
5575  VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
5576  VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
5577  VULKAN_HPP_NAMESPACE::Buffer scratch,
5578  VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset,
5580 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5581  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5582  void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
5583  VULKAN_HPP_NAMESPACE::Buffer instanceData,
5584  VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
5586  VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
5587  VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
5588  VULKAN_HPP_NAMESPACE::Buffer scratch,
5589  VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset,
5591 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5592 
5593  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5594  void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
5595  VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
5598 
5599  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5600  void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer,
5601  VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
5602  VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer,
5603  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
5604  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
5605  VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer,
5606  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
5607  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
5608  VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
5609  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
5610  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
5611  uint32_t width,
5612  uint32_t height,
5613  uint32_t depth,
5615 
5616  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5617  void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount,
5618  const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
5620  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5621  uint32_t firstQuery,
5623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5624  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5626  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
5628  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5629  uint32_t firstQuery,
5631 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5632 
5633  //=== VK_KHR_draw_indirect_count ===
5634 
5635  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5636  void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
5638  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5639  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5640  uint32_t maxDrawCount,
5641  uint32_t stride,
5643 
5644  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5645  void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
5647  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5648  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5649  uint32_t maxDrawCount,
5650  uint32_t stride,
5652 
5653  //=== VK_AMD_buffer_marker ===
5654 
5655  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5657  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5659  uint32_t marker,
5661 
5662  //=== VK_NV_mesh_shader ===
5663 
5664  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5665  void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5666 
5667  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5668  void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
5670  uint32_t drawCount,
5671  uint32_t stride,
5673 
5674  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5675  void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
5677  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5678  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5679  uint32_t maxDrawCount,
5680  uint32_t stride,
5682 
5683  //=== VK_NV_scissor_exclusive ===
5684 
5685  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5686  void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
5687  uint32_t exclusiveScissorCount,
5688  const VULKAN_HPP_NAMESPACE::Bool32 * pExclusiveScissorEnables,
5690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5691  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5692  void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
5693  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables,
5695 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5696 
5697  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5698  void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
5699  uint32_t exclusiveScissorCount,
5700  const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
5702 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5703  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5704  void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
5705  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
5707 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5708 
5709  //=== VK_NV_device_diagnostic_checkpoints ===
5710 
5711  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5712  void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5713 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5714  template <typename CheckpointMarkerType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5715  void setCheckpointNV( CheckpointMarkerType const & checkpointMarker,
5717 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5718 
5719  //=== VK_INTEL_performance_query ===
5720 
5721  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5722  VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
5724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5725  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5727  setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo,
5728  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5729 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5730 
5731  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5732  VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
5734 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5735  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5737  setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo,
5738  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5739 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5740 
5741  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5742  VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
5744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5745  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5747  setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo,
5748  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
5749 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5750 
5751  //=== VK_KHR_fragment_shading_rate ===
5752 
5753  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5754  void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D * pFragmentSize,
5757 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5758  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5759  void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize,
5762 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5763 
5764  //=== VK_EXT_line_rasterization ===
5765 
5766  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5767  void setLineStippleEXT( uint32_t lineStippleFactor,
5768  uint16_t lineStipplePattern,
5770 
5771  //=== VK_EXT_extended_dynamic_state ===
5772 
5773  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5775 
5776  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5778 
5779  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5782 
5783  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5784  void setViewportWithCountEXT( uint32_t viewportCount,
5785  const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
5787 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5788  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5789  void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
5791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5792 
5793  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5794  void setScissorWithCountEXT( uint32_t scissorCount,
5795  const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
5797 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5798  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5799  void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
5801 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5802 
5803  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5804  void bindVertexBuffers2EXT( uint32_t firstBinding,
5805  uint32_t bindingCount,
5806  const VULKAN_HPP_NAMESPACE::Buffer * pBuffers,
5807  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5808  const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
5809  const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
5811 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5812  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5814  uint32_t firstBinding,
5815  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
5816  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5817  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5818  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5820 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5821 
5822  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5825 
5826  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5829 
5830  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5833 
5834  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5837 
5838  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5841 
5842  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5846  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
5849 
5850  //=== VK_NV_device_generated_commands ===
5851 
5852  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5853  void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
5855 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5856  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5857  void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
5859 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5860 
5861  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5863  const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
5865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5866  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5868  const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo,
5870 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5871 
5872  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5874  VULKAN_HPP_NAMESPACE::Pipeline pipeline,
5875  uint32_t groupIndex,
5877 
5878  //=== VK_EXT_depth_bias_control ===
5879 
5880  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5881  void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT * pDepthBiasInfo,
5883 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5884  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5885  void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo,
5887 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5888 
5889  //=== VK_KHR_video_encode_queue ===
5890 
5891  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5892  void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
5894 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5895  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5896  void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo,
5898 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5899 
5900 #if defined( VK_ENABLE_BETA_EXTENSIONS )
5901  //=== VK_NV_cuda_kernel_launch ===
5902 
5903  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5904  void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV * pLaunchInfo,
5906 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5907  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5908  void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo,
5910 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5911 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
5912 
5913  //=== VK_KHR_synchronization2 ===
5914 
5915  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5916  void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
5917  const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
5919 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5920  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5921  void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
5922  const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
5924 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5925 
5926  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5927  void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
5930 
5931  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5932  void waitEvents2KHR( uint32_t eventCount,
5933  const VULKAN_HPP_NAMESPACE::Event * pEvents,
5934  const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfos,
5936 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5937  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5938  void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
5939  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos,
5941 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5942 
5943  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5944  void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo * pDependencyInfo,
5946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5947  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5948  void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo,
5950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5951 
5952  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5954  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5955  uint32_t query,
5957 
5958  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5960  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5962  uint32_t marker,
5964 
5965  //=== VK_EXT_descriptor_buffer ===
5966 
5967  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5968  void bindDescriptorBuffersEXT( uint32_t bufferCount,
5969  const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT * pBindingInfos,
5971 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5972  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5973  void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos,
5975 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5976 
5977  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5979  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5980  uint32_t firstSet,
5981  uint32_t setCount,
5982  const uint32_t * pBufferIndices,
5983  const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
5985 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
5986  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5988  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5989  uint32_t firstSet,
5990  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices,
5991  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5993 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
5994 
5995  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
5997  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5998  uint32_t set,
6000 
6001  //=== VK_NV_fragment_shading_rate_enums ===
6002 
6003  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6007 
6008  //=== VK_EXT_mesh_shader ===
6009 
6010  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6011  void drawMeshTasksEXT( uint32_t groupCountX,
6012  uint32_t groupCountY,
6013  uint32_t groupCountZ,
6015 
6016  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6017  void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
6019  uint32_t drawCount,
6020  uint32_t stride,
6022 
6023  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6024  void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
6026  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
6027  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6028  uint32_t maxDrawCount,
6029  uint32_t stride,
6031 
6032  //=== VK_KHR_copy_commands2 ===
6033 
6034  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6035  void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 * pCopyBufferInfo,
6037 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6038  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6039  void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo,
6041 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6042 
6043  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6044  void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 * pCopyImageInfo,
6046 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6047  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6048  void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo,
6050 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6051 
6052  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6053  void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 * pCopyBufferToImageInfo,
6055 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6056  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6057  void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo,
6059 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6060 
6061  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6062  void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 * pCopyImageToBufferInfo,
6064 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6065  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6066  void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo,
6068 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6069 
6070  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6071  void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 * pBlitImageInfo,
6073 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6074  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6075  void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo,
6077 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6078 
6079  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6080  void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 * pResolveImageInfo,
6082 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6083  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6084  void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo,
6086 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6087 
6088  //=== VK_EXT_vertex_input_dynamic_state ===
6089 
6090  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6091  void setVertexInputEXT( uint32_t vertexBindingDescriptionCount,
6092  const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
6093  uint32_t vertexAttributeDescriptionCount,
6094  const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
6096 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6097  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6098  void
6099  setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
6100  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
6102 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6103 
6104  //=== VK_HUAWEI_subpass_shading ===
6105 
6106  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6108 
6109  //=== VK_HUAWEI_invocation_mask ===
6110 
6111  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6112  void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView,
6115 
6116  //=== VK_EXT_extended_dynamic_state2 ===
6117 
6118  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6119  void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6120 
6121  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6124 
6125  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6128 
6129  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6131 
6132  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6135 
6136  //=== VK_EXT_color_write_enable ===
6137 
6138  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6139  void setColorWriteEnableEXT( uint32_t attachmentCount,
6140  const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
6142 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6143  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6144  void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
6146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6147 
6148  //=== VK_KHR_ray_tracing_maintenance1 ===
6149 
6150  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6153 
6154  //=== VK_EXT_multi_draw ===
6155 
6156  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6157  void drawMultiEXT( uint32_t drawCount,
6158  const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
6159  uint32_t instanceCount,
6160  uint32_t firstInstance,
6161  uint32_t stride,
6163 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6164  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6165  void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
6166  uint32_t instanceCount,
6167  uint32_t firstInstance,
6169 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6170 
6171  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6172  void drawMultiIndexedEXT( uint32_t drawCount,
6173  const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,
6174  uint32_t instanceCount,
6175  uint32_t firstInstance,
6176  uint32_t stride,
6177  const int32_t * pVertexOffset,
6179 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6180  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6181  void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
6182  uint32_t instanceCount,
6183  uint32_t firstInstance,
6186 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6187 
6188  //=== VK_EXT_opacity_micromap ===
6189 
6190  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6191  void buildMicromapsEXT( uint32_t infoCount,
6192  const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,
6194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6195  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6196  void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,
6198 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6199 
6200  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6201  void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,
6203 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6204  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6205  void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,
6207 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6208 
6209  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6210  void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,
6212 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6213  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6214  void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,
6216 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6217 
6218  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6219  void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,
6221 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6222  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6223  void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,
6225 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6226 
6227  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6228  void writeMicromapsPropertiesEXT( uint32_t micromapCount,
6229  const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
6231  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
6232  uint32_t firstQuery,
6234 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6235  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6236  void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
6238  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
6239  uint32_t firstQuery,
6241 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6242 
6243  //=== VK_HUAWEI_cluster_culling_shader ===
6244 
6245  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6246  void drawClusterHUAWEI( uint32_t groupCountX,
6247  uint32_t groupCountY,
6248  uint32_t groupCountZ,
6250 
6251  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6252  void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer,
6255 
6256  //=== VK_NV_copy_memory_indirect ===
6257 
6258  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6260  uint32_t copyCount,
6261  uint32_t stride,
6263 
6264  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6266  uint32_t copyCount,
6267  uint32_t stride,
6268  VULKAN_HPP_NAMESPACE::Image dstImage,
6269  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
6270  const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers * pImageSubresources,
6272 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6273  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6275  uint32_t stride,
6276  VULKAN_HPP_NAMESPACE::Image dstImage,
6277  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
6278  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources,
6280 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6281 
6282  //=== VK_NV_memory_decompression ===
6283 
6284  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6285  void decompressMemoryNV( uint32_t decompressRegionCount,
6286  const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV * pDecompressMemoryRegions,
6288 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6289  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6290  void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions,
6292 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6293 
6294  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6296  VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
6297  uint32_t stride,
6299 
6300  //=== VK_NV_device_generated_commands_compute ===
6301 
6302  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6304  VULKAN_HPP_NAMESPACE::Pipeline pipeline,
6306 
6307  //=== VK_EXT_extended_dynamic_state3 ===
6308 
6309  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6312 
6313  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6316 
6317  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6320 
6321  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6324 
6325  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6327  const VULKAN_HPP_NAMESPACE::SampleMask * pSampleMask,
6329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6330  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6332  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask,
6334 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6335 
6336  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6339 
6340  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6343 
6344  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6347 
6348  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6349  void setColorBlendEnableEXT( uint32_t firstAttachment,
6350  uint32_t attachmentCount,
6351  const VULKAN_HPP_NAMESPACE::Bool32 * pColorBlendEnables,
6353 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6354  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6355  void setColorBlendEnableEXT( uint32_t firstAttachment,
6356  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables,
6358 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6359 
6360  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6361  void setColorBlendEquationEXT( uint32_t firstAttachment,
6362  uint32_t attachmentCount,
6363  const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT * pColorBlendEquations,
6365 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6366  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6367  void setColorBlendEquationEXT( uint32_t firstAttachment,
6368  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations,
6370 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6371 
6372  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6373  void setColorWriteMaskEXT( uint32_t firstAttachment,
6374  uint32_t attachmentCount,
6375  const VULKAN_HPP_NAMESPACE::ColorComponentFlags * pColorWriteMasks,
6377 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6378  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6379  void setColorWriteMaskEXT( uint32_t firstAttachment,
6380  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks,
6382 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6383 
6384  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6385  void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6386 
6387  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6390 
6391  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6392  void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize,
6394 
6395  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6398 
6399  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6402 
6403  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6404  void setColorBlendAdvancedEXT( uint32_t firstAttachment,
6405  uint32_t attachmentCount,
6406  const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT * pColorBlendAdvanced,
6408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6409  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6410  void setColorBlendAdvancedEXT( uint32_t firstAttachment,
6411  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced,
6413 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6414 
6415  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6418 
6419  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6422 
6423  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6426 
6427  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6430 
6431  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6434 
6435  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6436  void setViewportSwizzleNV( uint32_t firstViewport,
6437  uint32_t viewportCount,
6438  const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * pViewportSwizzles,
6440 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6441  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6442  void setViewportSwizzleNV( uint32_t firstViewport,
6443  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles,
6445 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6446 
6447  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6450 
6451  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6452  void setCoverageToColorLocationNV( uint32_t coverageToColorLocation,
6454 
6455  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6458 
6459  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6462 
6463  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6464  void setCoverageModulationTableNV( uint32_t coverageModulationTableCount,
6465  const float * pCoverageModulationTable,
6467 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6468  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6469  void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable,
6471 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6472 
6473  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6476 
6477  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6480 
6481  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6484 
6485  //=== VK_NV_optical_flow ===
6486 
6487  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6488  void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
6489  const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV * pExecuteInfo,
6491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6492  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6493  void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
6494  const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo,
6496 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6497 
6498  //=== VK_KHR_maintenance5 ===
6499 
6500  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6501  void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
6506 
6507  //=== VK_EXT_shader_object ===
6508 
6509  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6510  void bindShadersEXT( uint32_t stageCount,
6512  const VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders,
6514 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6515  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6516  void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages,
6517  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders,
6519 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6520 
6521  //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
6522 
6523  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6526 
6527  //=== VK_KHR_maintenance6 ===
6528 
6529  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6530  void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR * pBindDescriptorSetsInfo,
6532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6533  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6534  void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR & bindDescriptorSetsInfo,
6536 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6537 
6538  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6539  void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR * pPushConstantsInfo,
6541 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6542  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6543  void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR & pushConstantsInfo,
6545 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6546 
6547  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6548  void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR * pPushDescriptorSetInfo,
6550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6551  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6552  void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR & pushDescriptorSetInfo,
6554 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6555 
6556  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6557  void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR * pPushDescriptorSetWithTemplateInfo,
6559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6560  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6561  void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR & pushDescriptorSetWithTemplateInfo,
6563 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6564 
6565  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6566  void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo,
6568 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6569  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6570  void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo,
6572 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6573 
6574  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6576  const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo,
6578 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6579  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6581  const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo,
6583 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
6584 
6586  {
6587  return m_commandBuffer;
6588  }
6589 
6590  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6591  {
6592  return m_commandBuffer != VK_NULL_HANDLE;
6593  }
6594 
6596  {
6597  return m_commandBuffer == VK_NULL_HANDLE;
6598  }
6599 
6600  private:
6601  VkCommandBuffer m_commandBuffer = {};
6602  };
6603 
6604  template <>
6605  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
6606  {
6607  using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
6608  };
6609 
6610  template <>
6611  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
6612  {
6613  using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
6614  };
6615 
6616  template <>
6617  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
6618  {
6619  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6620  };
6621 
6623  {
6624  public:
6627 
6628  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
6630  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
6631 
6632  public:
6634 
6636 
6637  VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {}
6638 
6639 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6640  DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
6641  {
6642  m_deviceMemory = deviceMemory;
6643  return *this;
6644  }
6645 #endif
6646 
6648  {
6649  m_deviceMemory = {};
6650  return *this;
6651  }
6652 
6653 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6654  auto operator<=>( DeviceMemory const & ) const = default;
6655 #else
6656  bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6657  {
6658  return m_deviceMemory == rhs.m_deviceMemory;
6659  }
6660 
6661  bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6662  {
6663  return m_deviceMemory != rhs.m_deviceMemory;
6664  }
6665 
6666  bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
6667  {
6668  return m_deviceMemory < rhs.m_deviceMemory;
6669  }
6670 #endif
6671 
6673  {
6674  return m_deviceMemory;
6675  }
6676 
6677  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6678  {
6679  return m_deviceMemory != VK_NULL_HANDLE;
6680  }
6681 
6683  {
6684  return m_deviceMemory == VK_NULL_HANDLE;
6685  }
6686 
6687  private:
6688  VkDeviceMemory m_deviceMemory = {};
6689  };
6690 
6691  template <>
6692  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
6693  {
6694  using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
6695  };
6696 
6697  template <>
6698  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
6699  {
6700  using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
6701  };
6702 
6703  template <>
6704  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
6705  {
6706  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6707  };
6708 
6710  {
6711  public:
6714 
6715  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
6717  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6718 
6719  public:
6721 
6723 
6724  VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {}
6725 
6726 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6727  VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
6728  {
6729  m_videoSessionKHR = videoSessionKHR;
6730  return *this;
6731  }
6732 #endif
6733 
6735  {
6736  m_videoSessionKHR = {};
6737  return *this;
6738  }
6739 
6740 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6741  auto operator<=>( VideoSessionKHR const & ) const = default;
6742 #else
6744  {
6745  return m_videoSessionKHR == rhs.m_videoSessionKHR;
6746  }
6747 
6749  {
6750  return m_videoSessionKHR != rhs.m_videoSessionKHR;
6751  }
6752 
6754  {
6755  return m_videoSessionKHR < rhs.m_videoSessionKHR;
6756  }
6757 #endif
6758 
6760  {
6761  return m_videoSessionKHR;
6762  }
6763 
6764  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6765  {
6766  return m_videoSessionKHR != VK_NULL_HANDLE;
6767  }
6768 
6770  {
6771  return m_videoSessionKHR == VK_NULL_HANDLE;
6772  }
6773 
6774  private:
6775  VkVideoSessionKHR m_videoSessionKHR = {};
6776  };
6777 
6778  template <>
6779  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
6780  {
6781  using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
6782  };
6783 
6784  template <>
6785  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
6786  {
6787  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6788  };
6789 
6791  {
6792  public:
6795 
6796  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
6798  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6799 
6800  public:
6802 
6804 
6806  : m_deferredOperationKHR( deferredOperationKHR )
6807  {
6808  }
6809 
6810 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6811  DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
6812  {
6813  m_deferredOperationKHR = deferredOperationKHR;
6814  return *this;
6815  }
6816 #endif
6817 
6819  {
6820  m_deferredOperationKHR = {};
6821  return *this;
6822  }
6823 
6824 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6825  auto operator<=>( DeferredOperationKHR const & ) const = default;
6826 #else
6828  {
6829  return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
6830  }
6831 
6833  {
6834  return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
6835  }
6836 
6838  {
6839  return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
6840  }
6841 #endif
6842 
6844  {
6845  return m_deferredOperationKHR;
6846  }
6847 
6848  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6849  {
6850  return m_deferredOperationKHR != VK_NULL_HANDLE;
6851  }
6852 
6854  {
6855  return m_deferredOperationKHR == VK_NULL_HANDLE;
6856  }
6857 
6858  private:
6859  VkDeferredOperationKHR m_deferredOperationKHR = {};
6860  };
6861 
6862  template <>
6863  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
6864  {
6865  using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
6866  };
6867 
6868  template <>
6869  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
6870  {
6871  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6872  };
6873 
6874 #if defined( VK_USE_PLATFORM_FUCHSIA )
6875  class BufferCollectionFUCHSIA
6876  {
6877  public:
6878  using CType = VkBufferCollectionFUCHSIA;
6879  using NativeType = VkBufferCollectionFUCHSIA;
6880 
6881  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
6883  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
6884 
6885  public:
6886  VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA() = default;
6887 
6888  VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6889 
6890  VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
6891  : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA )
6892  {
6893  }
6894 
6895 # if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6896  BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT
6897  {
6898  m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA;
6899  return *this;
6900  }
6901 # endif
6902 
6903  BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6904  {
6905  m_bufferCollectionFUCHSIA = {};
6906  return *this;
6907  }
6908 
6909 # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6910  auto operator<=>( BufferCollectionFUCHSIA const & ) const = default;
6911 # else
6912  bool operator==( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6913  {
6914  return m_bufferCollectionFUCHSIA == rhs.m_bufferCollectionFUCHSIA;
6915  }
6916 
6917  bool operator!=( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6918  {
6919  return m_bufferCollectionFUCHSIA != rhs.m_bufferCollectionFUCHSIA;
6920  }
6921 
6922  bool operator<( BufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
6923  {
6924  return m_bufferCollectionFUCHSIA < rhs.m_bufferCollectionFUCHSIA;
6925  }
6926 # endif
6927 
6928  VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
6929  {
6930  return m_bufferCollectionFUCHSIA;
6931  }
6932 
6933  explicit operator bool() const VULKAN_HPP_NOEXCEPT
6934  {
6935  return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE;
6936  }
6937 
6938  bool operator!() const VULKAN_HPP_NOEXCEPT
6939  {
6940  return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE;
6941  }
6942 
6943  private:
6944  VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {};
6945  };
6946 
6947  template <>
6948  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA>
6949  {
6950  using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
6951  };
6952 
6953  template <>
6954  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA>
6955  {
6956  using Type = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA;
6957  };
6958 
6959  template <>
6960  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
6961  {
6962  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6963  };
6964 #endif /*VK_USE_PLATFORM_FUCHSIA*/
6965 
6967  {
6968  public:
6971 
6972  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
6974  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
6975 
6976  public:
6978 
6980 
6981  VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {}
6982 
6983 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
6984  BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
6985  {
6986  m_bufferView = bufferView;
6987  return *this;
6988  }
6989 #endif
6990 
6992  {
6993  m_bufferView = {};
6994  return *this;
6995  }
6996 
6997 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6998  auto operator<=>( BufferView const & ) const = default;
6999 #else
7000  bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7001  {
7002  return m_bufferView == rhs.m_bufferView;
7003  }
7004 
7005  bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7006  {
7007  return m_bufferView != rhs.m_bufferView;
7008  }
7009 
7010  bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
7011  {
7012  return m_bufferView < rhs.m_bufferView;
7013  }
7014 #endif
7015 
7017  {
7018  return m_bufferView;
7019  }
7020 
7021  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7022  {
7023  return m_bufferView != VK_NULL_HANDLE;
7024  }
7025 
7027  {
7028  return m_bufferView == VK_NULL_HANDLE;
7029  }
7030 
7031  private:
7032  VkBufferView m_bufferView = {};
7033  };
7034 
7035  template <>
7036  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
7037  {
7038  using Type = VULKAN_HPP_NAMESPACE::BufferView;
7039  };
7040 
7041  template <>
7042  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
7043  {
7044  using Type = VULKAN_HPP_NAMESPACE::BufferView;
7045  };
7046 
7047  template <>
7048  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
7049  {
7050  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7051  };
7052 
7054  {
7055  public:
7058 
7059  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
7061  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
7062 
7063  public:
7065 
7067 
7068  VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {}
7069 
7070 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7071  CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
7072  {
7073  m_commandPool = commandPool;
7074  return *this;
7075  }
7076 #endif
7077 
7079  {
7080  m_commandPool = {};
7081  return *this;
7082  }
7083 
7084 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7085  auto operator<=>( CommandPool const & ) const = default;
7086 #else
7087  bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7088  {
7089  return m_commandPool == rhs.m_commandPool;
7090  }
7091 
7092  bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7093  {
7094  return m_commandPool != rhs.m_commandPool;
7095  }
7096 
7097  bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
7098  {
7099  return m_commandPool < rhs.m_commandPool;
7100  }
7101 #endif
7102 
7104  {
7105  return m_commandPool;
7106  }
7107 
7108  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7109  {
7110  return m_commandPool != VK_NULL_HANDLE;
7111  }
7112 
7114  {
7115  return m_commandPool == VK_NULL_HANDLE;
7116  }
7117 
7118  private:
7119  VkCommandPool m_commandPool = {};
7120  };
7121 
7122  template <>
7123  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
7124  {
7125  using Type = VULKAN_HPP_NAMESPACE::CommandPool;
7126  };
7127 
7128  template <>
7129  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
7130  {
7131  using Type = VULKAN_HPP_NAMESPACE::CommandPool;
7132  };
7133 
7134  template <>
7135  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
7136  {
7137  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7138  };
7139 
7141  {
7142  public:
7145 
7146  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
7148  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
7149 
7150  public:
7152 
7154 
7155  VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {}
7156 
7157 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7158  PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
7159  {
7160  m_pipelineCache = pipelineCache;
7161  return *this;
7162  }
7163 #endif
7164 
7166  {
7167  m_pipelineCache = {};
7168  return *this;
7169  }
7170 
7171 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7172  auto operator<=>( PipelineCache const & ) const = default;
7173 #else
7175  {
7176  return m_pipelineCache == rhs.m_pipelineCache;
7177  }
7178 
7180  {
7181  return m_pipelineCache != rhs.m_pipelineCache;
7182  }
7183 
7184  bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
7185  {
7186  return m_pipelineCache < rhs.m_pipelineCache;
7187  }
7188 #endif
7189 
7191  {
7192  return m_pipelineCache;
7193  }
7194 
7195  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7196  {
7197  return m_pipelineCache != VK_NULL_HANDLE;
7198  }
7199 
7201  {
7202  return m_pipelineCache == VK_NULL_HANDLE;
7203  }
7204 
7205  private:
7206  VkPipelineCache m_pipelineCache = {};
7207  };
7208 
7209  template <>
7210  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
7211  {
7212  using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
7213  };
7214 
7215  template <>
7216  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
7217  {
7218  using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
7219  };
7220 
7221  template <>
7222  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
7223  {
7224  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7225  };
7226 
7228  {
7229  public:
7232 
7233  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
7235  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
7236 
7237  public:
7239 
7241 
7242  VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {}
7243 
7244 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7245  CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
7246  {
7247  m_cuFunctionNVX = cuFunctionNVX;
7248  return *this;
7249  }
7250 #endif
7251 
7253  {
7254  m_cuFunctionNVX = {};
7255  return *this;
7256  }
7257 
7258 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7259  auto operator<=>( CuFunctionNVX const & ) const = default;
7260 #else
7262  {
7263  return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
7264  }
7265 
7267  {
7268  return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
7269  }
7270 
7271  bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7272  {
7273  return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
7274  }
7275 #endif
7276 
7278  {
7279  return m_cuFunctionNVX;
7280  }
7281 
7282  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7283  {
7284  return m_cuFunctionNVX != VK_NULL_HANDLE;
7285  }
7286 
7288  {
7289  return m_cuFunctionNVX == VK_NULL_HANDLE;
7290  }
7291 
7292  private:
7293  VkCuFunctionNVX m_cuFunctionNVX = {};
7294  };
7295 
7296  template <>
7297  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
7298  {
7299  using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
7300  };
7301 
7302  template <>
7303  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
7304  {
7305  using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
7306  };
7307 
7308  template <>
7309  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
7310  {
7311  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7312  };
7313 
7315  {
7316  public:
7319 
7320  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
7322  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
7323 
7324  public:
7326 
7328 
7329  VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {}
7330 
7331 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7332  CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
7333  {
7334  m_cuModuleNVX = cuModuleNVX;
7335  return *this;
7336  }
7337 #endif
7338 
7340  {
7341  m_cuModuleNVX = {};
7342  return *this;
7343  }
7344 
7345 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7346  auto operator<=>( CuModuleNVX const & ) const = default;
7347 #else
7348  bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7349  {
7350  return m_cuModuleNVX == rhs.m_cuModuleNVX;
7351  }
7352 
7353  bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7354  {
7355  return m_cuModuleNVX != rhs.m_cuModuleNVX;
7356  }
7357 
7358  bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
7359  {
7360  return m_cuModuleNVX < rhs.m_cuModuleNVX;
7361  }
7362 #endif
7363 
7365  {
7366  return m_cuModuleNVX;
7367  }
7368 
7369  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7370  {
7371  return m_cuModuleNVX != VK_NULL_HANDLE;
7372  }
7373 
7375  {
7376  return m_cuModuleNVX == VK_NULL_HANDLE;
7377  }
7378 
7379  private:
7380  VkCuModuleNVX m_cuModuleNVX = {};
7381  };
7382 
7383  template <>
7384  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
7385  {
7386  using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
7387  };
7388 
7389  template <>
7390  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
7391  {
7392  using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
7393  };
7394 
7395  template <>
7396  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
7397  {
7398  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7399  };
7400 
7401 #if defined( VK_ENABLE_BETA_EXTENSIONS )
7403  {
7404  public:
7407 
7408  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV;
7410  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV;
7411 
7412  public:
7414 
7416 
7417  VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {}
7418 
7419 # if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7420  CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT
7421  {
7422  m_cudaFunctionNV = cudaFunctionNV;
7423  return *this;
7424  }
7425 # endif
7426 
7428  {
7429  m_cudaFunctionNV = {};
7430  return *this;
7431  }
7432 
7433 # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7434  auto operator<=>( CudaFunctionNV const & ) const = default;
7435 # else
7437  {
7438  return m_cudaFunctionNV == rhs.m_cudaFunctionNV;
7439  }
7440 
7442  {
7443  return m_cudaFunctionNV != rhs.m_cudaFunctionNV;
7444  }
7445 
7447  {
7448  return m_cudaFunctionNV < rhs.m_cudaFunctionNV;
7449  }
7450 # endif
7451 
7453  {
7454  return m_cudaFunctionNV;
7455  }
7456 
7457  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7458  {
7459  return m_cudaFunctionNV != VK_NULL_HANDLE;
7460  }
7461 
7463  {
7464  return m_cudaFunctionNV == VK_NULL_HANDLE;
7465  }
7466 
7467  private:
7468  VkCudaFunctionNV m_cudaFunctionNV = {};
7469  };
7470 
7471  template <>
7472  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV>
7473  {
7474  using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
7475  };
7476 
7477  template <>
7478  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV>
7479  {
7480  using Type = VULKAN_HPP_NAMESPACE::CudaFunctionNV;
7481  };
7482 
7483  template <>
7484  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaFunctionNV>
7485  {
7486  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7487  };
7488 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
7489 
7490 #if defined( VK_ENABLE_BETA_EXTENSIONS )
7492  {
7493  public:
7496 
7497  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV;
7499  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV;
7500 
7501  public:
7503 
7505 
7506  VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {}
7507 
7508 # if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7509  CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT
7510  {
7511  m_cudaModuleNV = cudaModuleNV;
7512  return *this;
7513  }
7514 # endif
7515 
7517  {
7518  m_cudaModuleNV = {};
7519  return *this;
7520  }
7521 
7522 # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7523  auto operator<=>( CudaModuleNV const & ) const = default;
7524 # else
7525  bool operator==( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7526  {
7527  return m_cudaModuleNV == rhs.m_cudaModuleNV;
7528  }
7529 
7530  bool operator!=( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7531  {
7532  return m_cudaModuleNV != rhs.m_cudaModuleNV;
7533  }
7534 
7535  bool operator<( CudaModuleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
7536  {
7537  return m_cudaModuleNV < rhs.m_cudaModuleNV;
7538  }
7539 # endif
7540 
7542  {
7543  return m_cudaModuleNV;
7544  }
7545 
7546  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7547  {
7548  return m_cudaModuleNV != VK_NULL_HANDLE;
7549  }
7550 
7552  {
7553  return m_cudaModuleNV == VK_NULL_HANDLE;
7554  }
7555 
7556  private:
7557  VkCudaModuleNV m_cudaModuleNV = {};
7558  };
7559 
7560  template <>
7561  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV>
7562  {
7563  using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
7564  };
7565 
7566  template <>
7567  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV>
7568  {
7569  using Type = VULKAN_HPP_NAMESPACE::CudaModuleNV;
7570  };
7571 
7572  template <>
7573  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CudaModuleNV>
7574  {
7575  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7576  };
7577 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
7578 
7580  {
7581  public:
7584 
7585  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
7587  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
7588 
7589  public:
7591 
7593 
7594  VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {}
7595 
7596 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7597  DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
7598  {
7599  m_descriptorPool = descriptorPool;
7600  return *this;
7601  }
7602 #endif
7603 
7605  {
7606  m_descriptorPool = {};
7607  return *this;
7608  }
7609 
7610 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7611  auto operator<=>( DescriptorPool const & ) const = default;
7612 #else
7614  {
7615  return m_descriptorPool == rhs.m_descriptorPool;
7616  }
7617 
7619  {
7620  return m_descriptorPool != rhs.m_descriptorPool;
7621  }
7622 
7624  {
7625  return m_descriptorPool < rhs.m_descriptorPool;
7626  }
7627 #endif
7628 
7630  {
7631  return m_descriptorPool;
7632  }
7633 
7634  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7635  {
7636  return m_descriptorPool != VK_NULL_HANDLE;
7637  }
7638 
7640  {
7641  return m_descriptorPool == VK_NULL_HANDLE;
7642  }
7643 
7644  private:
7645  VkDescriptorPool m_descriptorPool = {};
7646  };
7647 
7648  template <>
7649  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
7650  {
7651  using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
7652  };
7653 
7654  template <>
7655  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
7656  {
7657  using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
7658  };
7659 
7660  template <>
7661  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
7662  {
7663  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7664  };
7665 
7667  {
7668  public:
7671 
7672  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
7674  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
7675 
7676  public:
7678 
7680 
7682  : m_descriptorSetLayout( descriptorSetLayout )
7683  {
7684  }
7685 
7686 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7687  DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
7688  {
7689  m_descriptorSetLayout = descriptorSetLayout;
7690  return *this;
7691  }
7692 #endif
7693 
7695  {
7696  m_descriptorSetLayout = {};
7697  return *this;
7698  }
7699 
7700 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7701  auto operator<=>( DescriptorSetLayout const & ) const = default;
7702 #else
7704  {
7705  return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
7706  }
7707 
7709  {
7710  return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
7711  }
7712 
7714  {
7715  return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
7716  }
7717 #endif
7718 
7720  {
7721  return m_descriptorSetLayout;
7722  }
7723 
7724  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7725  {
7726  return m_descriptorSetLayout != VK_NULL_HANDLE;
7727  }
7728 
7730  {
7731  return m_descriptorSetLayout == VK_NULL_HANDLE;
7732  }
7733 
7734  private:
7735  VkDescriptorSetLayout m_descriptorSetLayout = {};
7736  };
7737 
7738  template <>
7739  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
7740  {
7741  using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
7742  };
7743 
7744  template <>
7745  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
7746  {
7747  using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
7748  };
7749 
7750  template <>
7751  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
7752  {
7753  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7754  };
7755 
7757  {
7758  public:
7761 
7762  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
7764  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
7765 
7766  public:
7768 
7770 
7771  VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {}
7772 
7773 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7774  Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
7775  {
7776  m_framebuffer = framebuffer;
7777  return *this;
7778  }
7779 #endif
7780 
7782  {
7783  m_framebuffer = {};
7784  return *this;
7785  }
7786 
7787 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7788  auto operator<=>( Framebuffer const & ) const = default;
7789 #else
7790  bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7791  {
7792  return m_framebuffer == rhs.m_framebuffer;
7793  }
7794 
7795  bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7796  {
7797  return m_framebuffer != rhs.m_framebuffer;
7798  }
7799 
7800  bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
7801  {
7802  return m_framebuffer < rhs.m_framebuffer;
7803  }
7804 #endif
7805 
7807  {
7808  return m_framebuffer;
7809  }
7810 
7811  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7812  {
7813  return m_framebuffer != VK_NULL_HANDLE;
7814  }
7815 
7817  {
7818  return m_framebuffer == VK_NULL_HANDLE;
7819  }
7820 
7821  private:
7822  VkFramebuffer m_framebuffer = {};
7823  };
7824 
7825  template <>
7826  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
7827  {
7828  using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
7829  };
7830 
7831  template <>
7832  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
7833  {
7834  using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
7835  };
7836 
7837  template <>
7838  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
7839  {
7840  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7841  };
7842 
7844  {
7845  public:
7848 
7849  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
7851  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7852 
7853  public:
7855 
7857 
7859  : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
7860  {
7861  }
7862 
7863 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7864  IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
7865  {
7866  m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
7867  return *this;
7868  }
7869 #endif
7870 
7872  {
7873  m_indirectCommandsLayoutNV = {};
7874  return *this;
7875  }
7876 
7877 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7878  auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
7879 #else
7881  {
7882  return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
7883  }
7884 
7886  {
7887  return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
7888  }
7889 
7891  {
7892  return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
7893  }
7894 #endif
7895 
7897  {
7898  return m_indirectCommandsLayoutNV;
7899  }
7900 
7901  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7902  {
7903  return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
7904  }
7905 
7907  {
7908  return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
7909  }
7910 
7911  private:
7912  VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
7913  };
7914 
7915  template <>
7916  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
7917  {
7918  using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
7919  };
7920 
7921  template <>
7922  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
7923  {
7924  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
7925  };
7926 
7928  {
7929  public:
7932 
7933  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
7935  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7936 
7937  public:
7939 
7941 
7942  VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {}
7943 
7944 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
7945  PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT
7946  {
7947  m_privateDataSlot = privateDataSlot;
7948  return *this;
7949  }
7950 #endif
7951 
7953  {
7954  m_privateDataSlot = {};
7955  return *this;
7956  }
7957 
7958 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
7959  auto operator<=>( PrivateDataSlot const & ) const = default;
7960 #else
7962  {
7963  return m_privateDataSlot == rhs.m_privateDataSlot;
7964  }
7965 
7967  {
7968  return m_privateDataSlot != rhs.m_privateDataSlot;
7969  }
7970 
7972  {
7973  return m_privateDataSlot < rhs.m_privateDataSlot;
7974  }
7975 #endif
7976 
7978  {
7979  return m_privateDataSlot;
7980  }
7981 
7982  explicit operator bool() const VULKAN_HPP_NOEXCEPT
7983  {
7984  return m_privateDataSlot != VK_NULL_HANDLE;
7985  }
7986 
7988  {
7989  return m_privateDataSlot == VK_NULL_HANDLE;
7990  }
7991 
7992  private:
7993  VkPrivateDataSlot m_privateDataSlot = {};
7994  };
7995 
7996  template <>
7997  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot>
7998  {
7999  using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlot;
8000  };
8001 
8002  template <>
8003  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
8004  {
8005  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8006  };
8007 
8009 
8011  {
8012  public:
8015 
8016  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
8018  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
8019 
8020  public:
8022 
8024 
8025  VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {}
8026 
8027 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8028  RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
8029  {
8030  m_renderPass = renderPass;
8031  return *this;
8032  }
8033 #endif
8034 
8036  {
8037  m_renderPass = {};
8038  return *this;
8039  }
8040 
8041 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8042  auto operator<=>( RenderPass const & ) const = default;
8043 #else
8044  bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8045  {
8046  return m_renderPass == rhs.m_renderPass;
8047  }
8048 
8049  bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8050  {
8051  return m_renderPass != rhs.m_renderPass;
8052  }
8053 
8054  bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
8055  {
8056  return m_renderPass < rhs.m_renderPass;
8057  }
8058 #endif
8059 
8061  {
8062  return m_renderPass;
8063  }
8064 
8065  explicit operator bool() const VULKAN_HPP_NOEXCEPT
8066  {
8067  return m_renderPass != VK_NULL_HANDLE;
8068  }
8069 
8071  {
8072  return m_renderPass == VK_NULL_HANDLE;
8073  }
8074 
8075  private:
8076  VkRenderPass m_renderPass = {};
8077  };
8078 
8079  template <>
8080  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
8081  {
8082  using Type = VULKAN_HPP_NAMESPACE::RenderPass;
8083  };
8084 
8085  template <>
8086  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
8087  {
8088  using Type = VULKAN_HPP_NAMESPACE::RenderPass;
8089  };
8090 
8091  template <>
8092  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
8093  {
8094  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8095  };
8096 
8097  class Sampler
8098  {
8099  public:
8100  using CType = VkSampler;
8102 
8103  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
8105  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
8106 
8107  public:
8109 
8111 
8113 
8114 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8115  Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
8116  {
8117  m_sampler = sampler;
8118  return *this;
8119  }
8120 #endif
8121 
8123  {
8124  m_sampler = {};
8125  return *this;
8126  }
8127 
8128 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8129  auto operator<=>( Sampler const & ) const = default;
8130 #else
8131  bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8132  {
8133  return m_sampler == rhs.m_sampler;
8134  }
8135 
8136  bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8137  {
8138  return m_sampler != rhs.m_sampler;
8139  }
8140 
8141  bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
8142  {
8143  return m_sampler < rhs.m_sampler;
8144  }
8145 #endif
8146 
8148  {
8149  return m_sampler;
8150  }
8151 
8152  explicit operator bool() const VULKAN_HPP_NOEXCEPT
8153  {
8154  return m_sampler != VK_NULL_HANDLE;
8155  }
8156 
8158  {
8159  return m_sampler == VK_NULL_HANDLE;
8160  }
8161 
8162  private:
8163  VkSampler m_sampler = {};
8164  };
8165 
8166  template <>
8167  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
8168  {
8169  using Type = VULKAN_HPP_NAMESPACE::Sampler;
8170  };
8171 
8172  template <>
8173  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
8174  {
8175  using Type = VULKAN_HPP_NAMESPACE::Sampler;
8176  };
8177 
8178  template <>
8179  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
8180  {
8181  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8182  };
8183 
8185  {
8186  public:
8189 
8190  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
8192  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
8193 
8194  public:
8196 
8198 
8200  : m_samplerYcbcrConversion( samplerYcbcrConversion )
8201  {
8202  }
8203 
8204 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8205  SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
8206  {
8207  m_samplerYcbcrConversion = samplerYcbcrConversion;
8208  return *this;
8209  }
8210 #endif
8211 
8213  {
8214  m_samplerYcbcrConversion = {};
8215  return *this;
8216  }
8217 
8218 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8219  auto operator<=>( SamplerYcbcrConversion const & ) const = default;
8220 #else
8222  {
8223  return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
8224  }
8225 
8227  {
8228  return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
8229  }
8230 
8232  {
8233  return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
8234  }
8235 #endif
8236 
8238  {
8239  return m_samplerYcbcrConversion;
8240  }
8241 
8242  explicit operator bool() const VULKAN_HPP_NOEXCEPT
8243  {
8244  return m_samplerYcbcrConversion != VK_NULL_HANDLE;
8245  }
8246 
8248  {
8249  return m_samplerYcbcrConversion == VK_NULL_HANDLE;
8250  }
8251 
8252  private:
8253  VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
8254  };
8255 
8256  template <>
8257  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
8258  {
8259  using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
8260  };
8261 
8262  template <>
8263  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
8264  {
8265  using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
8266  };
8267 
8268  template <>
8269  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
8270  {
8271  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8272  };
8273 
8275 
8277  {
8278  public:
8281 
8282  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
8284  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
8285 
8286  public:
8288 
8290 
8291  VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {}
8292 
8293 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8294  ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
8295  {
8296  m_shaderModule = shaderModule;
8297  return *this;
8298  }
8299 #endif
8300 
8302  {
8303  m_shaderModule = {};
8304  return *this;
8305  }
8306 
8307 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8308  auto operator<=>( ShaderModule const & ) const = default;
8309 #else
8310  bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8311  {
8312  return m_shaderModule == rhs.m_shaderModule;
8313  }
8314 
8315  bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8316  {
8317  return m_shaderModule != rhs.m_shaderModule;
8318  }
8319 
8320  bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
8321  {
8322  return m_shaderModule < rhs.m_shaderModule;
8323  }
8324 #endif
8325 
8327  {
8328  return m_shaderModule;
8329  }
8330 
8331  explicit operator bool() const VULKAN_HPP_NOEXCEPT
8332  {
8333  return m_shaderModule != VK_NULL_HANDLE;
8334  }
8335 
8337  {
8338  return m_shaderModule == VK_NULL_HANDLE;
8339  }
8340 
8341  private:
8342  VkShaderModule m_shaderModule = {};
8343  };
8344 
8345  template <>
8346  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
8347  {
8348  using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
8349  };
8350 
8351  template <>
8352  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
8353  {
8354  using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
8355  };
8356 
8357  template <>
8358  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
8359  {
8360  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8361  };
8362 
8364  {
8365  public:
8368 
8369  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
8371  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
8372 
8373  public:
8375 
8377 
8378  VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT )
8379  {
8380  }
8381 
8382 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8383  ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
8384  {
8385  m_validationCacheEXT = validationCacheEXT;
8386  return *this;
8387  }
8388 #endif
8389 
8391  {
8392  m_validationCacheEXT = {};
8393  return *this;
8394  }
8395 
8396 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8397  auto operator<=>( ValidationCacheEXT const & ) const = default;
8398 #else
8400  {
8401  return m_validationCacheEXT == rhs.m_validationCacheEXT;
8402  }
8403 
8405  {
8406  return m_validationCacheEXT != rhs.m_validationCacheEXT;
8407  }
8408 
8410  {
8411  return m_validationCacheEXT < rhs.m_validationCacheEXT;
8412  }
8413 #endif
8414 
8416  {
8417  return m_validationCacheEXT;
8418  }
8419 
8420  explicit operator bool() const VULKAN_HPP_NOEXCEPT
8421  {
8422  return m_validationCacheEXT != VK_NULL_HANDLE;
8423  }
8424 
8426  {
8427  return m_validationCacheEXT == VK_NULL_HANDLE;
8428  }
8429 
8430  private:
8431  VkValidationCacheEXT m_validationCacheEXT = {};
8432  };
8433 
8434  template <>
8435  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
8436  {
8437  using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
8438  };
8439 
8440  template <>
8441  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
8442  {
8443  using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
8444  };
8445 
8446  template <>
8447  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
8448  {
8449  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8450  };
8451 
8453  {
8454  public:
8457 
8458  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
8460  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
8461 
8462  public:
8464 
8466 
8468  : m_videoSessionParametersKHR( videoSessionParametersKHR )
8469  {
8470  }
8471 
8472 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
8473  VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
8474  {
8475  m_videoSessionParametersKHR = videoSessionParametersKHR;
8476  return *this;
8477  }
8478 #endif
8479 
8481  {
8482  m_videoSessionParametersKHR = {};
8483  return *this;
8484  }
8485 
8486 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8487  auto operator<=>( VideoSessionParametersKHR const & ) const = default;
8488 #else
8490  {
8491  return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
8492  }
8493 
8495  {
8496  return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
8497  }
8498 
8500  {
8501  return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
8502  }
8503 #endif
8504 
8506  {
8507  return m_videoSessionParametersKHR;
8508  }
8509 
8510  explicit operator bool() const VULKAN_HPP_NOEXCEPT
8511  {
8512  return m_videoSessionParametersKHR != VK_NULL_HANDLE;
8513  }
8514 
8516  {
8517  return m_videoSessionParametersKHR == VK_NULL_HANDLE;
8518  }
8519 
8520  private:
8521  VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
8522  };
8523 
8524  template <>
8525  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
8526  {
8527  using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
8528  };
8529 
8530  template <>
8531  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
8532  {
8533  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8534  };
8535 
8536  class Queue
8537  {
8538  public:
8539  using CType = VkQueue;
8541 
8542  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
8544  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
8545 
8546  public:
8548 
8550 
8551  Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
8552 
8554  {
8555  m_queue = queue;
8556  return *this;
8557  }
8558 
8560  {
8561  m_queue = {};
8562  return *this;
8563  }
8564 
8565 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8566  auto operator<=>( Queue const & ) const = default;
8567 #else
8568  bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
8569  {
8570  return m_queue == rhs.m_queue;
8571  }
8572 
8573  bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
8574  {
8575  return m_queue != rhs.m_queue;
8576  }
8577 
8578  bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
8579  {
8580  return m_queue < rhs.m_queue;
8581  }
8582 #endif
8583 
8584  //=== VK_VERSION_1_0 ===
8585 
8586  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8587  VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount,
8588  const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
8589  VULKAN_HPP_NAMESPACE::Fence fence,
8591 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8592  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8594  submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
8595  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8596  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8597 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8598 
8599 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8600  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8602 #else
8603  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8605 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8606 
8607  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8608  VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount,
8609  const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
8610  VULKAN_HPP_NAMESPACE::Fence fence,
8612 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8613  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8615  bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
8616  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8617  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8618 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8619 
8620  //=== VK_VERSION_1_3 ===
8621 
8622  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8623  VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount,
8624  const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
8625  VULKAN_HPP_NAMESPACE::Fence fence,
8627 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8628  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8630  submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
8631  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8632  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8633 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8634 
8635  //=== VK_KHR_swapchain ===
8636 
8637  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8638  VULKAN_HPP_NODISCARD Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
8640 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8641  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8642  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo,
8643  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8644 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8645 
8646  //=== VK_EXT_debug_utils ===
8647 
8648  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8649  void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
8651 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8652  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8653  void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
8655 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8656 
8657  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8659 
8660  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8661  void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
8663 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8664  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8665  void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo,
8667 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8668 
8669  //=== VK_NV_device_diagnostic_checkpoints ===
8670 
8671  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8672  void getCheckpointDataNV( uint32_t * pCheckpointDataCount,
8673  VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
8675 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8676  template <typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
8677  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8678  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
8680  template <
8681  typename CheckpointDataNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointDataNV>,
8682  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8683  typename std::enable_if<std::is_same<typename CheckpointDataNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointDataNV>::value, int>::type = 0>
8684  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV, CheckpointDataNVAllocator>
8685  getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8686 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8687 
8688  //=== VK_INTEL_performance_query ===
8689 
8690 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8691  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8692  VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
8694 #else
8695  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8697  setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
8698  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8699 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8700 
8701  //=== VK_KHR_synchronization2 ===
8702 
8703  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8704  VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount,
8705  const VULKAN_HPP_NAMESPACE::SubmitInfo2 * pSubmits,
8706  VULKAN_HPP_NAMESPACE::Fence fence,
8708 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8709  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8711  submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
8712  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8713  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8714 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8715 
8716  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8717  void getCheckpointData2NV( uint32_t * pCheckpointDataCount,
8718  VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
8720 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8721  template <typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
8722  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8723  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
8725  template <
8726  typename CheckpointData2NVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CheckpointData2NV>,
8727  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8728  typename std::enable_if<std::is_same<typename CheckpointData2NVAllocator::value_type, VULKAN_HPP_NAMESPACE::CheckpointData2NV>::value, int>::type = 0>
8729  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV, CheckpointData2NVAllocator>
8730  getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8731 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8732 
8733  //=== VK_NV_low_latency2 ===
8734 
8735  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8736  void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV * pQueueTypeInfo,
8738 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8739  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8740  void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo,
8742 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8743 
8744  operator VkQueue() const VULKAN_HPP_NOEXCEPT
8745  {
8746  return m_queue;
8747  }
8748 
8749  explicit operator bool() const VULKAN_HPP_NOEXCEPT
8750  {
8751  return m_queue != VK_NULL_HANDLE;
8752  }
8753 
8755  {
8756  return m_queue == VK_NULL_HANDLE;
8757  }
8758 
8759  private:
8760  VkQueue m_queue = {};
8761  };
8762 
8763  template <>
8764  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
8765  {
8766  using Type = VULKAN_HPP_NAMESPACE::Queue;
8767  };
8768 
8769  template <>
8770  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
8771  {
8772  using Type = VULKAN_HPP_NAMESPACE::Queue;
8773  };
8774 
8775  template <>
8776  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
8777  {
8778  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
8779  };
8780 
8781  class Device
8782  {
8783  public:
8784  using CType = VkDevice;
8786 
8787  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
8789  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
8790 
8791  public:
8793 
8795 
8796  Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
8797 
8799  {
8800  m_device = device;
8801  return *this;
8802  }
8803 
8805  {
8806  m_device = {};
8807  return *this;
8808  }
8809 
8810 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
8811  auto operator<=>( Device const & ) const = default;
8812 #else
8813  bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
8814  {
8815  return m_device == rhs.m_device;
8816  }
8817 
8818  bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
8819  {
8820  return m_device != rhs.m_device;
8821  }
8822 
8823  bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
8824  {
8825  return m_device < rhs.m_device;
8826  }
8827 #endif
8828 
8829  //=== VK_VERSION_1_0 ===
8830 
8831  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8833 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8834  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8836 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8837 
8838  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8839  void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8841 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8842  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8845 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8846 
8847  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8848  void getQueue( uint32_t queueFamilyIndex,
8849  uint32_t queueIndex,
8850  VULKAN_HPP_NAMESPACE::Queue * pQueue,
8852 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8853  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8854  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
8855  getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8856 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8857 
8858 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8859  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8861 #else
8862  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8864 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8865 
8866  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8867  VULKAN_HPP_NODISCARD Result allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo * pAllocateInfo,
8868  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8869  VULKAN_HPP_NAMESPACE::DeviceMemory * pMemory,
8871 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8872  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8874  allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo,
8876  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8877 # ifndef VULKAN_HPP_NO_SMART_HANDLE
8878  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8880  allocateMemoryUnique( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo & allocateInfo,
8882  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8883 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
8884 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8885 
8886  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8887  void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8888  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8890 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8891  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8892  void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8895 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8896 
8897  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8898  void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8899  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8902  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8903  void( free )( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8906 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8907 
8908  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8909  VULKAN_HPP_NODISCARD Result mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8913  void ** ppData,
8915 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8916  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8917  VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8921  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8922 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8923 
8924  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8925  void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8926 
8927  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8929  const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
8931 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8932  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8934  flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
8935  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8936 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8937 
8938  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8940  const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
8942 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8943  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8945  invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
8946  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8947 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8948 
8949  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8950  void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8951  VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
8953 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8954  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8956  getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8957 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8958 
8959 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8960  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8961  VULKAN_HPP_NODISCARD Result bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer,
8962  VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8963  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
8965 #else
8966  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8968  bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer buffer,
8969  VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8970  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
8971  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8972 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8973 
8974 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8975  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8976  VULKAN_HPP_NODISCARD Result bindImageMemory( VULKAN_HPP_NAMESPACE::Image image,
8977  VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8978  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
8980 #else
8981  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8983  bindImageMemory( VULKAN_HPP_NAMESPACE::Image image,
8984  VULKAN_HPP_NAMESPACE::DeviceMemory memory,
8985  VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset,
8986  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8987 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8988 
8989  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8990  void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer,
8991  VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
8993 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8994  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8995  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements
8996  getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8997 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
8998 
8999  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9000  void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
9001  VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
9003 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9004  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9005  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements
9006  getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9007 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9008 
9009  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9010  void getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
9011  uint32_t * pSparseMemoryRequirementCount,
9012  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
9014 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9015  template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
9016  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9017  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
9018  getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9019  template <typename SparseImageMemoryRequirementsAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>,
9020  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9021  typename std::enable_if<
9022  std::is_same<typename SparseImageMemoryRequirementsAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>::value,
9023  int>::type = 0>
9024  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
9025  getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
9026  SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
9027  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9028 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9029 
9030  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9031  VULKAN_HPP_NODISCARD Result createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo * pCreateInfo,
9032  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9033  VULKAN_HPP_NAMESPACE::Fence * pFence,
9035 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9036  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9038  createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo,
9040  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9041 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9042  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9044  createFenceUnique( const VULKAN_HPP_NAMESPACE::FenceCreateInfo & createInfo,
9046  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9047 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9048 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9049 
9050  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9051  void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence,
9052  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9055  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9056  void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9059 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9060 
9061  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9062  void destroy( VULKAN_HPP_NAMESPACE::Fence fence,
9063  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9065 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9066  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9067  void destroy( VULKAN_HPP_NAMESPACE::Fence fence,
9070 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9071 
9072  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9074  const VULKAN_HPP_NAMESPACE::Fence * pFences,
9076 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9077  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9078  typename ResultValueType<void>::type resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
9079  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9080 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9081 
9082 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9083  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9084  VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
9086 #else
9087  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9089  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9090 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9091 
9092  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9094  const VULKAN_HPP_NAMESPACE::Fence * pFences,
9096  uint64_t timeout,
9098 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9099  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9100  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
9102  uint64_t timeout,
9103  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9104 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9105 
9106  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9107  VULKAN_HPP_NODISCARD Result createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
9108  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9109  VULKAN_HPP_NAMESPACE::Semaphore * pSemaphore,
9111 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9112  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9114  createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo,
9116  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9117 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9118  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9120  createSemaphoreUnique( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo & createInfo,
9122  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9123 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9124 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9125 
9126  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9127  void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
9128  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9130 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9131  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9132  void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9135 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9136 
9137  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9138  void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
9139  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9142  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9143  void destroy( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
9146 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9147 
9148  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9149  VULKAN_HPP_NODISCARD Result createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo * pCreateInfo,
9150  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9151  VULKAN_HPP_NAMESPACE::Event * pEvent,
9153 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9154  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9156  createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo,
9158  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9159 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9160  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9162  createEventUnique( const VULKAN_HPP_NAMESPACE::EventCreateInfo & createInfo,
9164  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9165 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9166 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9167 
9168  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9169  void destroyEvent( VULKAN_HPP_NAMESPACE::Event event,
9170  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9173  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9174  void destroyEvent( VULKAN_HPP_NAMESPACE::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9177 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9178 
9179  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9180  void destroy( VULKAN_HPP_NAMESPACE::Event event,
9181  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9184  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9185  void destroy( VULKAN_HPP_NAMESPACE::Event event,
9188 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9189 
9190 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9191  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9192  VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
9194 #else
9195  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9197  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9198 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9199 
9200 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9201  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9202  VULKAN_HPP_NODISCARD Result setEvent( VULKAN_HPP_NAMESPACE::Event event,
9204 #else
9205  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9207  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9208 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9209 
9210 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9211  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9212  VULKAN_HPP_NODISCARD Result resetEvent( VULKAN_HPP_NAMESPACE::Event event,
9214 #else
9215  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9216  typename ResultValueType<void>::type resetEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9217 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9218 
9219  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9220  VULKAN_HPP_NODISCARD Result createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
9221  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9222  VULKAN_HPP_NAMESPACE::QueryPool * pQueryPool,
9224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9225  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9227  createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo,
9229  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9230 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9231  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9233  createQueryPoolUnique( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo & createInfo,
9235  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9236 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9237 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9238 
9239  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9240  void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
9241  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9243 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9244  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9245  void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9248 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9249 
9250  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9251  void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
9252  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9254 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9255  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9256  void destroy( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
9259 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9260 
9261  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9262  VULKAN_HPP_NODISCARD Result getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
9263  uint32_t firstQuery,
9264  uint32_t queryCount,
9265  size_t dataSize,
9266  void * pData,
9270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9271  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9273  getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
9274  uint32_t firstQuery,
9275  uint32_t queryCount,
9276  size_t dataSize,
9279  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9280  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9281  VULKAN_HPP_NODISCARD ResultValue<DataType> getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
9282  uint32_t firstQuery,
9283  uint32_t queryCount,
9286  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9287 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9288 
9289  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9290  VULKAN_HPP_NODISCARD Result createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo * pCreateInfo,
9291  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9292  VULKAN_HPP_NAMESPACE::Buffer * pBuffer,
9294 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9295  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9297  createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo,
9299  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9300 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9301  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9303  createBufferUnique( const VULKAN_HPP_NAMESPACE::BufferCreateInfo & createInfo,
9305  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9306 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9307 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9308 
9309  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9310  void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer,
9311  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9313 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9314  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9315  void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9318 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9319 
9320  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9321  void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer,
9322  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9325  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9326  void destroy( VULKAN_HPP_NAMESPACE::Buffer buffer,
9329 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9330 
9331  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9332  VULKAN_HPP_NODISCARD Result createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
9333  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9334  VULKAN_HPP_NAMESPACE::BufferView * pView,
9336 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9337  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9339  createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo,
9341  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9342 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9343  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9345  createBufferViewUnique( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo & createInfo,
9347  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9348 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9349 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9350 
9351  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9352  void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView,
9353  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9355 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9356  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9357  void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9360 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9361 
9362  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9363  void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView,
9364  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9367  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9368  void destroy( VULKAN_HPP_NAMESPACE::BufferView bufferView,
9371 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9372 
9373  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9374  VULKAN_HPP_NODISCARD Result createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo * pCreateInfo,
9375  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9376  VULKAN_HPP_NAMESPACE::Image * pImage,
9378 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9379  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9381  createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo,
9383  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9384 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9385  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9387  createImageUnique( const VULKAN_HPP_NAMESPACE::ImageCreateInfo & createInfo,
9389  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9390 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9391 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9392 
9393  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9394  void destroyImage( VULKAN_HPP_NAMESPACE::Image image,
9395  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9398  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9399  void destroyImage( VULKAN_HPP_NAMESPACE::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9402 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9403 
9404  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9405  void destroy( VULKAN_HPP_NAMESPACE::Image image,
9406  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9409  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9410  void destroy( VULKAN_HPP_NAMESPACE::Image image,
9413 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9414 
9415  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9416  void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image,
9417  const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
9418  VULKAN_HPP_NAMESPACE::SubresourceLayout * pLayout,
9420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9421  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9422  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout
9423  getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image image,
9424  const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource,
9426 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9427 
9428  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9429  VULKAN_HPP_NODISCARD Result createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
9430  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9431  VULKAN_HPP_NAMESPACE::ImageView * pView,
9433 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9434  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9436  createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo,
9438  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9439 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9440  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9442  createImageViewUnique( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo & createInfo,
9444  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9445 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9446 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9447 
9448  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9449  void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView,
9450  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9452 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9453  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9454  void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9457 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9458 
9459  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9460  void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView,
9461  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9463 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9464  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9465  void destroy( VULKAN_HPP_NAMESPACE::ImageView imageView,
9468 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9469 
9470  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9471  VULKAN_HPP_NODISCARD Result createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
9472  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9473  VULKAN_HPP_NAMESPACE::ShaderModule * pShaderModule,
9475 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9476  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9478  createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
9480  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9481 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9482  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9484  createShaderModuleUnique( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
9486  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9487 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9488 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9489 
9490  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9491  void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
9492  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9495  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9496  void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9499 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9500 
9501  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9502  void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
9503  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9505 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9506  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9507  void destroy( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
9510 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9511 
9512  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9513  VULKAN_HPP_NODISCARD Result createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
9514  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9515  VULKAN_HPP_NAMESPACE::PipelineCache * pPipelineCache,
9517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9520  createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo,
9522  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9523 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9524  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9526  createPipelineCacheUnique( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo & createInfo,
9528  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9529 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9530 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9531 
9532  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9533  void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9534  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9536 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9537  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9538  void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9541 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9542 
9543  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9544  void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9545  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9547 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9548  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9549  void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9552 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9553 
9554  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9555  VULKAN_HPP_NODISCARD Result getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9556  size_t * pDataSize,
9557  void * pData,
9559 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9560  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9562  getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9563  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
9564  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9565  typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
9567  getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9568  Uint8_tAllocator & uint8_tAllocator,
9569  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9570 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9571 
9572  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9573  VULKAN_HPP_NODISCARD Result mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache,
9574  uint32_t srcCacheCount,
9575  const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
9577 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9578  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9580  mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache dstCache,
9581  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
9582  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9583 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9584 
9585  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9586  VULKAN_HPP_NODISCARD Result createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9587  uint32_t createInfoCount,
9588  const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
9589  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9590  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
9592 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9593  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9595  createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9596  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9598  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9599  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
9600  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9601  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
9603  createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9604  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9606  PipelineAllocator & pipelineAllocator,
9607  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9608  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9610  createGraphicsPipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9611  const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
9613  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9614 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9615  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9616  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9618  createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9619  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9621  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9622  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9623  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
9624  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
9625  int>::type = 0>
9627  createGraphicsPipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9628  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9630  PipelineAllocator & pipelineAllocator,
9631  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9632  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9634  createGraphicsPipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9635  const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
9637  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9638 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9639 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9640 
9641  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9642  VULKAN_HPP_NODISCARD Result createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9643  uint32_t createInfoCount,
9644  const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,
9645  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9646  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
9648 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9649  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9651  createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9652  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9654  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9655  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
9656  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9657  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
9659  createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9660  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9662  PipelineAllocator & pipelineAllocator,
9663  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9664  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9666  createComputePipeline( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9667  const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
9669  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9670 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9671  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9672  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
9674  createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9675  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9677  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9678  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9679  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
9680  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
9681  int>::type = 0>
9683  createComputePipelinesUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9684  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9686  PipelineAllocator & pipelineAllocator,
9687  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9688  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9690  createComputePipelineUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
9691  const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
9693  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9694 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9695 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9696 
9697  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9698  void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
9699  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9702  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9703  void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9706 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9707 
9708  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9709  void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
9710  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9713  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9714  void destroy( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
9717 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9718 
9719  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9720  VULKAN_HPP_NODISCARD Result createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
9721  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9722  VULKAN_HPP_NAMESPACE::PipelineLayout * pPipelineLayout,
9724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9725  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9727  createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo,
9729  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9730 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9731  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9733  createPipelineLayoutUnique( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo & createInfo,
9735  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9736 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9737 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9738 
9739  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9740  void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
9741  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9744  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9745  void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9748 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9749 
9750  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9751  void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
9752  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9754 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9755  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9756  void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
9759 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9760 
9761  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9762  VULKAN_HPP_NODISCARD Result createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo * pCreateInfo,
9763  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9764  VULKAN_HPP_NAMESPACE::Sampler * pSampler,
9766 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9767  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9769  createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo,
9771  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9772 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9773  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9775  createSamplerUnique( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo & createInfo,
9777  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9778 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9779 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9780 
9781  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9782  void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler,
9783  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9785 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9786  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9787  void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9790 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9791 
9792  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9793  void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler,
9794  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9797  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9798  void destroy( VULKAN_HPP_NAMESPACE::Sampler sampler,
9801 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9802 
9803  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9804  VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
9805  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9806  VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayout,
9808 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9809  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9811  createDescriptorSetLayout( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
9813  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9814 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9815  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9817  createDescriptorSetLayoutUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
9819  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9820 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9821 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9822 
9823  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9824  void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
9825  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9827 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9828  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9829  void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9832 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9833 
9834  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9835  void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
9836  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9838 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9839  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9840  void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
9843 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9844 
9845  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9846  VULKAN_HPP_NODISCARD Result createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
9847  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9848  VULKAN_HPP_NAMESPACE::DescriptorPool * pDescriptorPool,
9850 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9851  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9853  createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo,
9855  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9856 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9857  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9859  createDescriptorPoolUnique( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo & createInfo,
9861  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9862 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9863 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9864 
9865  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9866  void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9867  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9869 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9870  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9871  void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9874 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9875 
9876  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9877  void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9878  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9880 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9881  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9882  void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9885 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9886 
9887 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9888  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9889  Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9892 #else
9893  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9894  void resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9897 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9898 
9899  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9900  VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
9901  VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
9903 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9904  template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9906  allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
9907  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9908  template <typename DescriptorSetAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DescriptorSet>,
9909  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9910  typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, VULKAN_HPP_NAMESPACE::DescriptorSet>::value, int>::type = 0>
9912  allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
9913  DescriptorSetAllocator & descriptorSetAllocator,
9914  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9915 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9916  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9917  typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>>
9919  allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
9920  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9921  template <
9922  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9923  typename DescriptorSetAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>,
9924  typename std::enable_if<std::is_same<typename DescriptorSetAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSet, Dispatch>>::value,
9925  int>::type = 0>
9927  allocateDescriptorSetsUnique( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo & allocateInfo,
9928  DescriptorSetAllocator & descriptorSetAllocator,
9929  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9930 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9931 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9932 
9933  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9934  Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9935  uint32_t descriptorSetCount,
9936  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
9938 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9939  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9940  void freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9941  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
9943 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9944 
9945  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9946  Result( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9947  uint32_t descriptorSetCount,
9948  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
9950 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9951  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9952  void( free )( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
9953  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
9955 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9956 
9957  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9958  void updateDescriptorSets( uint32_t descriptorWriteCount,
9959  const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
9960  uint32_t descriptorCopyCount,
9961  const VULKAN_HPP_NAMESPACE::CopyDescriptorSet * pDescriptorCopies,
9963 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9964  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9965  void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
9966  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies,
9968 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9969 
9970  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9971  VULKAN_HPP_NODISCARD Result createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
9972  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9973  VULKAN_HPP_NAMESPACE::Framebuffer * pFramebuffer,
9975 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9976  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9978  createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo,
9980  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9981 # ifndef VULKAN_HPP_NO_SMART_HANDLE
9982  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9984  createFramebufferUnique( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo & createInfo,
9986  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9987 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
9988 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
9989 
9990  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9991  void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
9992  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9994 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9995  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9996  void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9999 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10000 
10001  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10002  void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
10003  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10005 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10006  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10007  void destroy( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
10010 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10011 
10012  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10013  VULKAN_HPP_NODISCARD Result createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
10014  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10015  VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
10017 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10018  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10020  createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo,
10022  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10023 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10024  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10026  createRenderPassUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo & createInfo,
10028  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10029 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10030 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10031 
10032  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10033  void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10034  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10037  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10038  void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10041 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10042 
10043  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10044  void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10045  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10047 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10048  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10049  void destroy( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10052 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10053 
10054  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10055  void getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10056  VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
10058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10059  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10060  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
10061  getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
10063 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10064 
10065  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10066  VULKAN_HPP_NODISCARD Result createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
10067  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10068  VULKAN_HPP_NAMESPACE::CommandPool * pCommandPool,
10070 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10071  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10073  createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo,
10075  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10076 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10077  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10079  createCommandPoolUnique( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo & createInfo,
10081  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10082 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10083 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10084 
10085  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10086  void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10087  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10089 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10090  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10091  void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10094 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10095 
10096  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10097  void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10098  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10100 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10101  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10102  void destroy( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10105 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10106 
10107 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10108  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10109  VULKAN_HPP_NODISCARD Result resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10112 #else
10113  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10114  typename ResultValueType<void>::type resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10116  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10117 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10118 
10119  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10120  VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
10121  VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
10123 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10124  template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10126  allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10127  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10128  template <typename CommandBufferAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CommandBuffer>,
10129  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10130  typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, VULKAN_HPP_NAMESPACE::CommandBuffer>::value, int>::type = 0>
10132  allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10133  CommandBufferAllocator & commandBufferAllocator,
10134  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10135 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10136  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10137  typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>>
10139  allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10140  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10141  template <
10142  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10143  typename CommandBufferAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>,
10144  typename std::enable_if<std::is_same<typename CommandBufferAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::CommandBuffer, Dispatch>>::value,
10145  int>::type = 0>
10147  allocateCommandBuffersUnique( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo & allocateInfo,
10148  CommandBufferAllocator & commandBufferAllocator,
10149  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10150 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10151 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10152 
10153  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10154  void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10155  uint32_t commandBufferCount,
10156  const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
10158 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10159  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10160  void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10161  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
10163 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10164 
10165  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10166  void( free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10167  uint32_t commandBufferCount,
10168  const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
10170 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10171  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10172  void( free )( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10173  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
10175 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10176 
10177  //=== VK_VERSION_1_1 ===
10178 
10179  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10181  const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
10183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10184  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10186  bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
10187  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10188 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10189 
10190  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10192  const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
10194 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10195  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10197  bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
10198  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10199 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10200 
10201  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10202  void getGroupPeerMemoryFeatures( uint32_t heapIndex,
10203  uint32_t localDeviceIndex,
10204  uint32_t remoteDeviceIndex,
10205  VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
10207 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10208  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10210  getGroupPeerMemoryFeatures( uint32_t heapIndex,
10211  uint32_t localDeviceIndex,
10212  uint32_t remoteDeviceIndex,
10214 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10215 
10216  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10217  void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
10218  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
10220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10221  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10222  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10223  getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10225  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10226  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10227  getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
10229 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10230 
10231  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10232  void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
10233  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
10235 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10236  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10237  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10238  getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10240  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10241  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10242  getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
10244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10245 
10246  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10247  void getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
10248  uint32_t * pSparseMemoryRequirementCount,
10249  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
10251 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10252  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10253  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10254  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10255  getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10256  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10257  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10258  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10259  typename std::enable_if<
10260  std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
10261  int>::type = 0>
10262  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10263  getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
10264  SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
10265  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10266 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10267 
10268  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10269  void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
10272 
10273  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10274  void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
10275  VULKAN_HPP_NAMESPACE::Queue * pQueue,
10277 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10278  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10279  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 & queueInfo,
10281 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10282 
10283  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10284  VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
10285  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10286  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion,
10288 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10289  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10291  createSamplerYcbcrConversion( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
10293  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10294 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10295  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10297  createSamplerYcbcrConversionUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
10299  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10300 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10301 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10302 
10303  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10304  void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
10305  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10308  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10309  void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10312 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10313 
10314  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10315  void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
10316  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10318 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10319  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10320  void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
10323 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10324 
10325  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10326  VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
10327  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10328  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
10330 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10331  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10333  createDescriptorUpdateTemplate( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
10335  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10336 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10337  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10339  createDescriptorUpdateTemplateUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
10341  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10342 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10343 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10344 
10345  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10346  void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10347  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10349 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10350  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10351  void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10354 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10355 
10356  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10357  void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10358  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10360 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10361  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10362  void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10365 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10366 
10367  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10368  void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
10369  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10370  const void * pData,
10372 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10373  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10374  void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
10375  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
10376  DataType const & data,
10378 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10379 
10380  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10381  void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
10382  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport,
10384 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10385  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10386  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
10387  getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
10389  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10390  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10391  getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
10393 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10394 
10395  //=== VK_VERSION_1_2 ===
10396 
10397  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10398  VULKAN_HPP_NODISCARD Result createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
10399  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10400  VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
10402 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10403  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10405  createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
10407  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10408 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10409  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10411  createRenderPass2Unique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
10413  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10414 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10415 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10416 
10417  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10418  void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
10419  uint32_t firstQuery,
10420  uint32_t queryCount,
10422 
10423  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10424  VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
10425  uint64_t * pValue,
10427 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10428  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10429  VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
10430  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10432 
10433  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10434  VULKAN_HPP_NODISCARD Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
10435  uint64_t timeout,
10437 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10438  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10439  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
10440  uint64_t timeout,
10441  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10442 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10443 
10444  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10445  VULKAN_HPP_NODISCARD Result signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
10447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10448  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10450  signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10451 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10452 
10453  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10454  DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
10456 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10457  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10458  VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
10460 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10461 
10462  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10463  uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
10465 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10466  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10467  uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
10469 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10470 
10471  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10472  uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
10474 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10475  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10476  uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
10478 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10479 
10480  //=== VK_VERSION_1_3 ===
10481 
10482  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10483  VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,
10484  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10485  VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot,
10487 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10488  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10490  createPrivateDataSlot( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo,
10492  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10493 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10494  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10496  createPrivateDataSlotUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo,
10498  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10499 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10500 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10501 
10502  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10503  void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10504  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10506 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10507  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10508  void destroyPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10511 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10512 
10513  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10514  void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10515  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10519  void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10522 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10523 
10524 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10525  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10526  VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
10527  uint64_t objectHandle,
10528  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10529  uint64_t data,
10531 #else
10532  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10534  uint64_t objectHandle,
10535  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10536  uint64_t data,
10537  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10538 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10539 
10540  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10542  uint64_t objectHandle,
10543  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10544  uint64_t * pData,
10546 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10547  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10549  uint64_t objectHandle,
10550  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
10552 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10553 
10554  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10555  void getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,
10556  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
10558 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10559  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10560  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10561  getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
10563  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10564  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10565  getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
10567 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10568 
10569  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10570  void getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
10571  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
10573 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10574  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10575  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
10576  getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
10578  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10579  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
10580  getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
10582 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10583 
10584  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10585  void getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
10586  uint32_t * pSparseMemoryRequirementCount,
10587  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
10589 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10590  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10591  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10592  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10593  getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
10594  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10595  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
10596  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10597  typename std::enable_if<
10598  std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
10599  int>::type = 0>
10600  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
10601  getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
10602  SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
10603  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10604 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10605 
10606  //=== VK_KHR_swapchain ===
10607 
10608  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10609  VULKAN_HPP_NODISCARD Result createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
10610  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10611  VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchain,
10613 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10614  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10616  createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
10618  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10619 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10620  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10622  createSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
10624  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10625 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10626 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10627 
10628  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10629  void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10630  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10632 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10633  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10634  void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10637 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10638 
10639  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10640  void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10641  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10643 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10644  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10645  void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10648 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10649 
10650  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10651  VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10652  uint32_t * pSwapchainImageCount,
10653  VULKAN_HPP_NAMESPACE::Image * pSwapchainImages,
10655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10656  template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10658  getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10659  template <typename ImageAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Image>,
10660  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10661  typename std::enable_if<std::is_same<typename ImageAllocator::value_type, VULKAN_HPP_NAMESPACE::Image>::value, int>::type = 0>
10663  VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, ImageAllocator & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10664 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10665 
10666  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10667  VULKAN_HPP_NODISCARD Result acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10668  uint64_t timeout,
10669  VULKAN_HPP_NAMESPACE::Semaphore semaphore,
10670  VULKAN_HPP_NAMESPACE::Fence fence,
10671  uint32_t * pImageIndex,
10673 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10674  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10675  VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10676  uint64_t timeout,
10677  VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10678  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10679  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10680 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10681 
10682  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10683  VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
10685 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10686  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10689 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10690 
10691  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10692  VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
10695 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10696  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10698  getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10699 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10700 
10701  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10702  VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
10703  uint32_t * pImageIndex,
10705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10706  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10707  VULKAN_HPP_NODISCARD ResultValue<uint32_t> acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo,
10708  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10709 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10710 
10711  //=== VK_KHR_display_swapchain ===
10712 
10713  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10715  const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
10716  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10717  VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains,
10719 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10720  template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10722  createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
10724  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10725  template <typename SwapchainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SwapchainKHR>,
10726  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10727  typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SwapchainKHR>::value, int>::type = 0>
10729  createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
10731  SwapchainKHRAllocator & swapchainKHRAllocator,
10732  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10733  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10735  createSharedSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
10737  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10738 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10739  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10740  typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>>
10742  createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
10744  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10745  template <
10746  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10747  typename SwapchainKHRAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>,
10748  typename std::enable_if<std::is_same<typename SwapchainKHRAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::value,
10749  int>::type = 0>
10751  createSharedSwapchainsKHRUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
10753  SwapchainKHRAllocator & swapchainKHRAllocator,
10754  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10755  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10757  createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
10759  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10760 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10761 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10762 
10763  //=== VK_EXT_debug_marker ===
10764 
10765  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10766  VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
10768 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10769  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10771  debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo,
10772  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10773 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10774 
10775  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10776  VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
10778 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10779  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10781  debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo,
10782  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10783 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10784 
10785  //=== VK_KHR_video_queue ===
10786 
10787  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10788  VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
10789  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10790  VULKAN_HPP_NAMESPACE::VideoSessionKHR * pVideoSession,
10792 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10793  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10795  createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo,
10797  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10798 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10799  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10801  createVideoSessionKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR & createInfo,
10803  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10804 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10805 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10806 
10807  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10808  void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10809  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10811 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10812  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10813  void destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10816 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10817 
10818  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10819  void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10820  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10822 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10823  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10824  void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10827 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10828 
10829  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10830  VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10831  uint32_t * pMemoryRequirementsCount,
10832  VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR * pMemoryRequirements,
10834 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10835  template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
10836  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10839  getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10840  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10841  template <typename VideoSessionMemoryRequirementsKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>,
10842  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10843  typename std::enable_if<
10844  std::is_same<typename VideoSessionMemoryRequirementsKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR>::value,
10845  int>::type = 0>
10848  getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10849  VideoSessionMemoryRequirementsKHRAllocator & videoSessionMemoryRequirementsKHRAllocator,
10850  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10851 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10852 
10853  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10854  VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10855  uint32_t bindSessionMemoryInfoCount,
10856  const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos,
10858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10859  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10861  bindVideoSessionMemoryKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
10862  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos,
10863  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10864 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10865 
10866  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10867  VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
10868  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10869  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR * pVideoSessionParameters,
10871 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10872  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10874  createVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo,
10876  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10877 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10878  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10880  createVideoSessionParametersKHRUnique( const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR & createInfo,
10882  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10883 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10884 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10885 
10886  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10887  VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
10888  const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
10890 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10891  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10893  updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
10894  const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo,
10895  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10896 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10897 
10898  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10899  void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
10900  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10902 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10903  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10904  void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10907 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10908 
10909  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10910  void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
10911  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10914  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10915  void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
10918 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10919 
10920  //=== VK_NVX_binary_import ===
10921 
10922  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10923  VULKAN_HPP_NODISCARD Result createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
10924  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10925  VULKAN_HPP_NAMESPACE::CuModuleNVX * pModule,
10927 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10928  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10930  createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo,
10932  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10933 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10934  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10936  createCuModuleNVXUnique( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX & createInfo,
10938  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10939 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10940 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10941 
10942  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10943  VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
10944  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10945  VULKAN_HPP_NAMESPACE::CuFunctionNVX * pFunction,
10947 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10948  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10950  createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo,
10952  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10953 # ifndef VULKAN_HPP_NO_SMART_HANDLE
10954  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10956  createCuFunctionNVXUnique( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX & createInfo,
10958  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10959 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
10960 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10961 
10962  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10963  void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
10964  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10966 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10967  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10968  void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
10971 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10972 
10973  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10974  void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
10975  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10977 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10978  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10979  void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX module,
10982 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10983 
10984  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10985  void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
10986  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10988 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10989  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10990  void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
10993 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
10994 
10995  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10996  void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
10997  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10999 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11000  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11001  void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
11004 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11005 
11006  //=== VK_NVX_image_view_handle ===
11007 
11008  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11009  uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
11011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11012  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11013  uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info,
11015 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11016 
11017  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11018  VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
11019  VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
11021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11022  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11024  getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11025 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11026 
11027  //=== VK_AMD_shader_info ===
11028 
11029  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11030  VULKAN_HPP_NODISCARD Result getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11033  size_t * pInfoSize,
11034  void * pInfo,
11036 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11037  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11039  getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11042  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11043  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
11044  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11045  typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
11047  getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11050  Uint8_tAllocator & uint8_tAllocator,
11051  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11052 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11053 
11054 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11055  //=== VK_NV_external_memory_win32 ===
11056 
11057  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11058  VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
11060  HANDLE * pHandle,
11062 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11063  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11064  VULKAN_HPP_NODISCARD typename ResultValueType<HANDLE>::type getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
11066  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11067 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11068 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11069 
11070  //=== VK_KHR_device_group ===
11071 
11072  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11073  void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
11074  uint32_t localDeviceIndex,
11075  uint32_t remoteDeviceIndex,
11076  VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
11078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11079  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11081  getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex,
11082  uint32_t localDeviceIndex,
11083  uint32_t remoteDeviceIndex,
11085 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11086 
11087  //=== VK_KHR_maintenance1 ===
11088 
11089  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11090  void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool commandPool,
11093 
11094 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11095  //=== VK_KHR_external_memory_win32 ===
11096 
11097  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11098  VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
11099  HANDLE * pHandle,
11101 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11102  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11104  getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
11105  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11106 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11107 
11108  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11109  VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11110  HANDLE handle,
11111  VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
11113 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11114  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11116  VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11117 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11118 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11119 
11120  //=== VK_KHR_external_memory_fd ===
11121 
11122  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11123  VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
11124  int * pFd,
11126 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11127  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11128  VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo,
11129  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11130 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11131 
11132  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11134  int fd,
11135  VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR * pMemoryFdProperties,
11137 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11138  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11141 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11142 
11143 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11144  //=== VK_KHR_external_semaphore_win32 ===
11145 
11146  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11147  VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
11149 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11150  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11152  importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
11153  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11154 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11155 
11156  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11157  VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
11158  HANDLE * pHandle,
11160 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11161  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11163  getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
11164  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11165 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11166 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11167 
11168  //=== VK_KHR_external_semaphore_fd ===
11169 
11170  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11171  VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
11173 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11174  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11176  importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
11177  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11178 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11179 
11180  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11181  VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
11182  int * pFd,
11184 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11185  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11186  VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo,
11187  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11188 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11189 
11190  //=== VK_KHR_descriptor_update_template ===
11191 
11192  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11193  VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
11194  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11195  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate * pDescriptorUpdateTemplate,
11197 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11198  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11200  createDescriptorUpdateTemplateKHR( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
11202  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11203 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11204  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11206  createDescriptorUpdateTemplateKHRUnique( const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo & createInfo,
11209  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11210 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11211 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11212 
11213  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11214  void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11215  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11217 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11218  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11219  void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11222 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11223 
11224  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11225  void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
11226  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11227  const void * pData,
11229 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11230  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11231  void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
11232  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
11233  DataType const & data,
11235 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11236 
11237  //=== VK_EXT_display_control ===
11238 
11239  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11240  VULKAN_HPP_NODISCARD Result displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
11241  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
11243 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11244  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11245  typename ResultValueType<void>::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
11246  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo,
11247  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11248 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11249 
11250  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11251  VULKAN_HPP_NODISCARD Result registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT * pDeviceEventInfo,
11252  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11253  VULKAN_HPP_NAMESPACE::Fence * pFence,
11255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11256  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11258  registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo,
11260  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11261 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11262  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11264  registerEventEXTUnique( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT & deviceEventInfo,
11266  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11267 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11268 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11269 
11270  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11271  VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
11272  const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
11273  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11274  VULKAN_HPP_NAMESPACE::Fence * pFence,
11276 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11277  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11279  registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
11280  const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo,
11282  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11283 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11284  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11286  registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
11287  const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT & displayEventInfo,
11289  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11290 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11291 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11292 
11293  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11294  VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11296  uint64_t * pCounterValue,
11298 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11299  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11300  VULKAN_HPP_NODISCARD typename ResultValueType<uint64_t>::type getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11302  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11303 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11304 
11305  //=== VK_GOOGLE_display_timing ===
11306 
11307  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11308  VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11309  VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
11311 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11312  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11314  getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11315 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11316 
11317  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11318  VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11319  uint32_t * pPresentationTimingCount,
11320  VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
11322 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11323  template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
11324  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11326  getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11327  template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>,
11328  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11329  typename std::enable_if<
11330  std::is_same<typename PastPresentationTimingGOOGLEAllocator::value_type, VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>::value,
11331  int>::type = 0>
11333  getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11334  PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
11335  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11336 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11337 
11338  //=== VK_EXT_hdr_metadata ===
11339 
11340  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11341  void setHdrMetadataEXT( uint32_t swapchainCount,
11342  const VULKAN_HPP_NAMESPACE::SwapchainKHR * pSwapchains,
11343  const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
11345 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11346  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11347  void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,
11348  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
11350 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11351 
11352  //=== VK_KHR_create_renderpass2 ===
11353 
11354  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11355  VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
11356  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11357  VULKAN_HPP_NAMESPACE::RenderPass * pRenderPass,
11359 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11360  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11362  createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
11364  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11365 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11366  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11368  createRenderPass2KHRUnique( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 & createInfo,
11370  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11371 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11373 
11374  //=== VK_KHR_shared_presentable_image ===
11375 
11376 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
11377  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11378  VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11380 #else
11381  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11382  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
11383  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11384 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11385 
11386 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11387  //=== VK_KHR_external_fence_win32 ===
11388 
11389  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11390  VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
11392 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11393  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11395  importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
11396  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11397 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11398 
11399  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11400  VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
11401  HANDLE * pHandle,
11403 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11404  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11406  getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
11407  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11408 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11409 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11410 
11411  //=== VK_KHR_external_fence_fd ===
11412 
11413  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11414  VULKAN_HPP_NODISCARD Result importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
11416 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11417  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11419  importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo,
11420  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11421 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11422 
11423  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11424  VULKAN_HPP_NODISCARD Result getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
11425  int * pFd,
11427 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11428  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11429  VULKAN_HPP_NODISCARD typename ResultValueType<int>::type getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo,
11430  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11431 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11432 
11433  //=== VK_KHR_performance_query ===
11434 
11435  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11436  VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
11438 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11439  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11441  acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info,
11442  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11443 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11444 
11445  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11447 
11448  //=== VK_EXT_debug_utils ===
11449 
11450  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11451  VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
11453 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11454  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11456  setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo,
11457  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11458 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11459 
11460  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11461  VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
11463 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11464  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11466  setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo,
11467  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11468 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11469 
11470 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
11471  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
11472 
11473  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11475  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer,
11476  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
11478 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11479  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11481  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11482  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11483  VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
11484  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11485 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11486 
11487  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11488  VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
11489  struct AHardwareBuffer ** pBuffer,
11491 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11492  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11494  getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info,
11495  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11496 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11497 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
11498 
11499 #if defined( VK_ENABLE_BETA_EXTENSIONS )
11500  //=== VK_AMDX_shader_enqueue ===
11501 
11502  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11503  VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11504  uint32_t createInfoCount,
11505  const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
11506  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11507  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
11509 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11510  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11512  createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11513  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
11515  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11516  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
11517  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11518  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
11520  createExecutionGraphPipelinesAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11521  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
11523  PipelineAllocator & pipelineAllocator,
11524  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11525  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11527  createExecutionGraphPipelineAMDX( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11528  const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX & createInfo,
11530  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11531 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11532  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11533  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
11536  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11537  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
11539  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11540  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11541  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
11542  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
11543  int>::type = 0>
11546  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11547  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
11549  PipelineAllocator & pipelineAllocator,
11550  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11551  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11553  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11554  const VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX & createInfo,
11556  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11557 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11558 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11559 
11560  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11562  getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph,
11563  VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo,
11565 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11566  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11568  getExecutionGraphPipelineScratchSizeAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph,
11569  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11570 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11571 
11572  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11573  VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph,
11574  const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
11575  uint32_t * pNodeIndex,
11577 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11578  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11580  getExecutionGraphPipelineNodeIndexAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph,
11581  const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo,
11582  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11583 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11584 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
11585 
11586  //=== VK_KHR_get_memory_requirements2 ===
11587 
11588  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11589  void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
11590  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
11592 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11593  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11594  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
11595  getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
11597  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11598  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11599  getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info,
11601 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11602 
11603  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11604  void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
11605  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
11607 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11608  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11609  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
11610  getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
11612  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11613  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
11614  getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info,
11616 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11617 
11618  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11619  void getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
11620  uint32_t * pSparseMemoryRequirementCount,
11621  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
11623 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11624  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
11625  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11626  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11627  getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
11628  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11629  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
11630  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11631  typename std::enable_if<
11632  std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
11633  int>::type = 0>
11634  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
11635  getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info,
11636  SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
11637  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11638 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11639 
11640  //=== VK_KHR_acceleration_structure ===
11641 
11642  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11643  VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
11644  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11645  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructure,
11647 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11648  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11650  createAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo,
11652  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11653 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11654  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11656  createAccelerationStructureKHRUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR & createInfo,
11658  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11659 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11660 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11661 
11662  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11663  void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
11664  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11667  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11668  void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11671 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11672 
11673  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11674  void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
11675  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11677 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11678  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11679  void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
11682 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11683 
11684  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11685  VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11686  uint32_t infoCount,
11687  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
11688  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
11690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11691  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11693  VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11694  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
11695  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
11696  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11697 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11698 
11699  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11700  VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11701  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
11703 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11704  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11705  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11706  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info,
11707  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11708 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11709 
11710  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11711  VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11712  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
11714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11715  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11717  copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11718  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info,
11719  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11720 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11721 
11722  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11723  VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11724  const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
11726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11727  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11729  copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11730  const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info,
11731  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11732 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11733 
11734  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11736  writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount,
11737  const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
11739  size_t dataSize,
11740  void * pData,
11741  size_t stride,
11743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11744  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11746  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
11748  size_t dataSize,
11749  size_t stride,
11750  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11751  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11753  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
11755  size_t stride,
11756  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11757 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11758 
11759  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11760  DeviceAddress getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
11762 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11763  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11765  getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info,
11767 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11768 
11769  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11770  void getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
11773 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11774  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11776  getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo,
11778 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11779 
11780  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11782  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
11783  const uint32_t * pMaxPrimitiveCounts,
11784  VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR * pSizeInfo,
11786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11787  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11788  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(
11790  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo,
11791  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11793 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11794 
11795  //=== VK_KHR_ray_tracing_pipeline ===
11796 
11797  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11798  VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11799  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11800  uint32_t createInfoCount,
11801  const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,
11802  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11803  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
11805 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11806  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11808  createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11809  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11810  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11812  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11813  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
11814  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11815  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
11817  createRayTracingPipelinesKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11818  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11819  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11821  PipelineAllocator & pipelineAllocator,
11822  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11823  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11825  createRayTracingPipelineKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11826  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11827  const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
11829  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11830 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11831  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11832  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
11834  createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11835  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11836  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11838  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11839  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11840  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
11841  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
11842  int>::type = 0>
11844  createRayTracingPipelinesKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11845  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11846  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
11848  PipelineAllocator & pipelineAllocator,
11849  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11850  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11852  createRayTracingPipelineKHRUnique( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
11853  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
11854  const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
11856  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11857 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11858 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11859 
11860  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11861  VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11862  uint32_t firstGroup,
11863  uint32_t groupCount,
11864  size_t dataSize,
11865  void * pData,
11867 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11868  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11870  getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11871  uint32_t firstGroup,
11872  uint32_t groupCount,
11873  size_t dataSize,
11874  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11875  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11877  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11878 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11879 
11880  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11882  getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11883  uint32_t firstGroup,
11884  uint32_t groupCount,
11885  size_t dataSize,
11886  void * pData,
11888 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11889  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11891  getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11892  uint32_t firstGroup,
11893  uint32_t groupCount,
11894  size_t dataSize,
11895  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11896  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11898  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11899 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11900 
11901  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11902  DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11903  uint32_t group,
11906 
11907  //=== VK_KHR_sampler_ycbcr_conversion ===
11908 
11909  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11910  VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
11911  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11912  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion * pYcbcrConversion,
11914 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11915  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11917  createSamplerYcbcrConversionKHR( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
11919  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11920 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11921  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11923  createSamplerYcbcrConversionKHRUnique( const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo & createInfo,
11925  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11926 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11927 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11928 
11929  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11930  void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
11931  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11933 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11934  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11935  void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11938 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11939 
11940  //=== VK_KHR_bind_memory2 ===
11941 
11942  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11944  const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
11946 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11947  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11949  bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
11950  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11951 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11952 
11953  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11955  const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
11957 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11958  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11960  bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
11961  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11962 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11963 
11964  //=== VK_EXT_image_drm_format_modifier ===
11965 
11966  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11968  VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
11970 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11971  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11973  getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11974 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11975 
11976  //=== VK_EXT_validation_cache ===
11977 
11978  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11979  VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
11980  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11981  VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pValidationCache,
11983 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11984  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11986  createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo,
11988  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11989 # ifndef VULKAN_HPP_NO_SMART_HANDLE
11990  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11992  createValidationCacheEXTUnique( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT & createInfo,
11994  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11995 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
11996 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
11997 
11998  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11999  void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12000  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12002 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12003  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12004  void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12007 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12008 
12009  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12010  void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12011  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12013 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12014  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12015  void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12018 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12019 
12020  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12021  VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache,
12022  uint32_t srcCacheCount,
12023  const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
12025 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12026  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12028  mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT dstCache,
12029  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
12030  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12031 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12032 
12033  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12034  VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12035  size_t * pDataSize,
12036  void * pData,
12038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12039  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12041  getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12042  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
12043  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12044  typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
12046  getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
12047  Uint8_tAllocator & uint8_tAllocator,
12048  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12049 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12050 
12051  //=== VK_NV_ray_tracing ===
12052 
12053  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12054  VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
12055  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12056  VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructure,
12058 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12059  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12061  createAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo,
12063  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12064 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12065  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12067  createAccelerationStructureNVUnique( const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV & createInfo,
12069  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12070 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12071 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12072 
12073  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12074  void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12075  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12077 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12078  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12079  void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12082 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12083 
12084  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12085  void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12086  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12088 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12089  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12090  void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12093 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12094 
12095  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12096  void getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
12097  VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR * pMemoryRequirements,
12099 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12100  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12102  getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
12104  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12105  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12106  getAccelerationStructureMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info,
12108 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12109 
12110  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12112  const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
12114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12115  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12117  bindAccelerationStructureMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
12118  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12119 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12120 
12121  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12122  VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12123  uint32_t createInfoCount,
12124  const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
12125  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12126  VULKAN_HPP_NAMESPACE::Pipeline * pPipelines,
12128 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12129  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12131  createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12132  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12134  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12135  template <typename PipelineAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Pipeline>,
12136  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12137  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, VULKAN_HPP_NAMESPACE::Pipeline>::value, int>::type = 0>
12139  createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12140  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12142  PipelineAllocator & pipelineAllocator,
12143  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12144  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12146  createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12147  const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
12149  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12150 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12151  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12152  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>>
12154  createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12155  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12157  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12158  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12159  typename PipelineAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>,
12160  typename std::enable_if<std::is_same<typename PipelineAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::Pipeline, Dispatch>>::value,
12161  int>::type = 0>
12163  createRayTracingPipelinesNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12164  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
12166  PipelineAllocator & pipelineAllocator,
12167  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12168  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12170  createRayTracingPipelineNVUnique( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
12171  const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
12173  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12174 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12175 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12176 
12177  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12178  VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12179  uint32_t firstGroup,
12180  uint32_t groupCount,
12181  size_t dataSize,
12182  void * pData,
12184 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12185  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12187  getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12188  uint32_t firstGroup,
12189  uint32_t groupCount,
12190  size_t dataSize,
12191  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12192  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12194  VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12195 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12196 
12197  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12198  VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12199  size_t dataSize,
12200  void * pData,
12202 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12203  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12205  VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12206  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12208  getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
12209  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12210 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12211 
12212 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12213  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12214  VULKAN_HPP_NODISCARD Result compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
12215  uint32_t shader,
12217 #else
12218  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12220  compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12221 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12222 
12223  //=== VK_KHR_maintenance3 ===
12224 
12225  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12226  void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
12227  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport * pSupport,
12229 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12230  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12231  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
12232  getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
12234  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12235  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12236  getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo,
12238 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12239 
12240  //=== VK_EXT_external_memory_host ===
12241 
12242  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12244  const void * pHostPointer,
12245  VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
12247 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12248  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12251  const void * pHostPointer,
12252  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12253 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12254 
12255  //=== VK_EXT_calibrated_timestamps ===
12256 
12257  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12259  const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
12260  uint64_t * pTimestamps,
12261  uint64_t * pMaxDeviation,
12263 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12264  template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12266  getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
12267  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12268  template <typename Uint64_tAllocator = std::allocator<uint64_t>,
12269  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12270  typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
12272  getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
12273  Uint64_tAllocator & uint64_tAllocator,
12274  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12275  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12277  getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
12278  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12279 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12280 
12281  //=== VK_KHR_timeline_semaphore ===
12282 
12283  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12284  VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
12285  uint64_t * pValue,
12287 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12288  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12290  getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12291 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12292 
12293  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12294  VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
12295  uint64_t timeout,
12297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12298  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12299  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
12300  uint64_t timeout,
12301  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12302 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12303 
12304  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12305  VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
12307 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12308  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12310  signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12311 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12312 
12313  //=== VK_INTEL_performance_query ===
12314 
12315  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12316  VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
12318 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12319  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12321  initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo,
12322  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12323 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12324 
12325  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12327 
12328  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12329  VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
12330  VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL * pConfiguration,
12332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12333  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12335  acquirePerformanceConfigurationINTEL( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
12336  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12337 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12338  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12340  acquirePerformanceConfigurationINTELUnique( const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
12341  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12342 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12343 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12344 
12345 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12346  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12347  VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
12349 #else
12350  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12352  releasePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12353  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12354 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12355 
12356 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12357  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12358  VULKAN_HPP_NODISCARD Result release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
12360 #else
12361  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12362  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
12363  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12364 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12365 
12366  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12368  VULKAN_HPP_NAMESPACE::PerformanceValueINTEL * pValue,
12370 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12371  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12374  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12375 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12376 
12377  //=== VK_AMD_display_native_hdr ===
12378 
12379  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12380  void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
12381  VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable,
12383 
12384  //=== VK_EXT_buffer_device_address ===
12385 
12386  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12387  DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
12389 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12390  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12391  VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
12393 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12394 
12395  //=== VK_KHR_present_wait ===
12396 
12397 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12398  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12399  VULKAN_HPP_NODISCARD Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12400  uint64_t presentId,
12401  uint64_t timeout,
12403 #else
12404  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12405  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresentKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12406  uint64_t presentId,
12407  uint64_t timeout,
12408  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12409 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12410 
12411 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12412  //=== VK_EXT_full_screen_exclusive ===
12413 
12414 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12415  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12416  VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12418 # else
12419  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12421  acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12422 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12423 
12424 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12425  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12426  VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
12428 # else
12429  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12431  releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12432 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12433 
12434  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12435  VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
12438 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12439  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12441  getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
12442  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12443 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12444 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12445 
12446  //=== VK_KHR_buffer_device_address ===
12447 
12448  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12449  DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
12451 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12452  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12453  VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
12455 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12456 
12457  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12458  uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
12460 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12461  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12462  uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info,
12464 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12465 
12466  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12467  uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
12469 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12470  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12471  uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info,
12473 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12474 
12475  //=== VK_EXT_host_query_reset ===
12476 
12477  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12478  void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
12479  uint32_t firstQuery,
12480  uint32_t queryCount,
12482 
12483  //=== VK_KHR_deferred_host_operations ===
12484 
12485  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12486  VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12487  VULKAN_HPP_NAMESPACE::DeferredOperationKHR * pDeferredOperation,
12489 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12490  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12493  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12494 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12495  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12498  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12499 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12500 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12501 
12502  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12503  void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12504  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12506 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12507  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12508  void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12511 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12512 
12513  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12514  void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12515  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12518  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12519  void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12522 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12523 
12524  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12525  uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12527 
12528 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12529  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12530  VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12532 #else
12533  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12535  getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12537 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12538 
12539 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12540  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12541  VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12543 #else
12544  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12545  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
12546  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12547 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12548 
12549  //=== VK_KHR_pipeline_executable_properties ===
12550 
12551  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12552  VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR * pPipelineInfo,
12553  uint32_t * pExecutableCount,
12554  VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
12556 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12557  template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
12558  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12561  getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
12562  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12563  template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>,
12564  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12565  typename std::enable_if<
12566  std::is_same<typename PipelineExecutablePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>::value,
12567  int>::type = 0>
12570  getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo,
12571  PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
12572  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12573 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12574 
12575  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12576  VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
12577  uint32_t * pStatisticCount,
12578  VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR * pStatistics,
12580 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12581  template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
12582  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12585  getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
12586  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12587  template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>,
12588  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12589  typename std::enable_if<
12590  std::is_same<typename PipelineExecutableStatisticKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>::value,
12591  int>::type = 0>
12594  getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
12595  PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
12596  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12597 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12598 
12599  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12601  getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
12602  uint32_t * pInternalRepresentationCount,
12603  VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
12605 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12606  template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
12607  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12609  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
12610  getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
12611  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12612  template <typename PipelineExecutableInternalRepresentationKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>,
12613  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12614  typename std::enable_if<std::is_same<typename PipelineExecutableInternalRepresentationKHRAllocator::value_type,
12615  VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value,
12616  int>::type = 0>
12618  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator>>::type
12620  const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo,
12621  PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
12622  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12623 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12624 
12625  //=== VK_EXT_host_image_copy ===
12626 
12627  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12628  VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT * pCopyMemoryToImageInfo,
12630 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12631  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12633  copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo,
12634  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12635 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12636 
12637  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12638  VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT * pCopyImageToMemoryInfo,
12640 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12641  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12643  copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo,
12644  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12645 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12646 
12647  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12648  VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT * pCopyImageToImageInfo,
12650 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12651  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12653  copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo,
12654  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12655 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12656 
12657  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12659  const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT * pTransitions,
12661 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12662  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12664  transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> const & transitions,
12665  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12666 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12667 
12668  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12669  void getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image,
12670  const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource,
12671  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout,
12673 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12674  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12675  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
12676  getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image,
12677  const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
12679  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12680  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12681  getImageSubresourceLayout2EXT( VULKAN_HPP_NAMESPACE::Image image,
12682  const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
12684 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12685 
12686  //=== VK_KHR_map_memory2 ===
12687 
12688  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12689  VULKAN_HPP_NODISCARD Result mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR * pMemoryMapInfo,
12690  void ** ppData,
12692 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12693  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12694  VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo,
12695  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12696 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12697 
12698  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12699  Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo,
12701 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12702  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12703  void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo,
12705 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12706 
12707  //=== VK_EXT_swapchain_maintenance1 ===
12708 
12709  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12710  VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT * pReleaseInfo,
12712 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12713  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12714  typename ResultValueType<void>::type releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo,
12715  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12716 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12717 
12718  //=== VK_NV_device_generated_commands ===
12719 
12720  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12721  void getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
12722  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
12724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12725  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12726  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
12727  getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
12729  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12730  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12731  getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info,
12733 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12734 
12735  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12736  VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
12737  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12738  VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV * pIndirectCommandsLayout,
12740 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12741  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12743  createIndirectCommandsLayoutNV( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo,
12745  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12746 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12747  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12749  createIndirectCommandsLayoutNVUnique( const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV & createInfo,
12751  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12752 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12753 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12754 
12755  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12756  void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
12757  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12759 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12760  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12761  void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12764 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12765 
12766  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12767  void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
12768  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12770 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12771  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12772  void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
12775 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12776 
12777  //=== VK_EXT_private_data ===
12778 
12779  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12780  VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo * pCreateInfo,
12781  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12782  VULKAN_HPP_NAMESPACE::PrivateDataSlot * pPrivateDataSlot,
12784 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12785  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12787  createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo,
12789  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12790 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12791  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12793  createPrivateDataSlotEXTUnique( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo & createInfo,
12795  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12796 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12797 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12798 
12799  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12800  void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12801  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12803 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12804  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12805  void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12808 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12809 
12810 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12811  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12812  VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
12813  uint64_t objectHandle,
12814  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12815  uint64_t data,
12817 #else
12818  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12820  uint64_t objectHandle,
12821  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12822  uint64_t data,
12823  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12824 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12825 
12826  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12828  uint64_t objectHandle,
12829  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12830  uint64_t * pData,
12832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12833  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12835  uint64_t objectHandle,
12836  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12838 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12839 
12840  //=== VK_KHR_video_encode_queue ===
12841 
12842  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12844  getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
12845  VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo,
12846  size_t * pDataSize,
12847  void * pData,
12849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12850  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12853  getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
12854  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12855  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
12856  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12857  typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
12860  getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
12861  Uint8_tAllocator & uint8_tAllocator,
12862  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12863  template <typename X,
12864  typename Y,
12865  typename... Z,
12866  typename Uint8_tAllocator = std::allocator<uint8_t>,
12867  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12868  VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
12869  getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
12870  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12871  template <typename X,
12872  typename Y,
12873  typename... Z,
12874  typename Uint8_tAllocator = std::allocator<uint8_t>,
12875  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12876  typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
12877  VULKAN_HPP_NODISCARD typename ResultValueType<std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t, Uint8_tAllocator>>>::type
12878  getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo,
12879  Uint8_tAllocator & uint8_tAllocator,
12880  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12881 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12882 
12883 #if defined( VK_ENABLE_BETA_EXTENSIONS )
12884  //=== VK_NV_cuda_kernel_launch ===
12885 
12886  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12887  VULKAN_HPP_NODISCARD Result createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV * pCreateInfo,
12888  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12889  VULKAN_HPP_NAMESPACE::CudaModuleNV * pModule,
12891 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12892  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12894  createCudaModuleNV( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV & createInfo,
12896  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12897 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12898  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12900  createCudaModuleNVUnique( const VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV & createInfo,
12902  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12903 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12904 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12905 
12906  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12907  VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module,
12908  size_t * pCacheSize,
12909  void * pCacheData,
12911 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12912  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12914  getCudaModuleCacheNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12915  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
12916  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12917  typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
12919  VULKAN_HPP_NAMESPACE::CudaModuleNV module, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12920 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12921 
12922  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12923  VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV * pCreateInfo,
12924  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12925  VULKAN_HPP_NAMESPACE::CudaFunctionNV * pFunction,
12927 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12928  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12930  createCudaFunctionNV( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV & createInfo,
12932  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12933 # ifndef VULKAN_HPP_NO_SMART_HANDLE
12934  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12936  createCudaFunctionNVUnique( const VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV & createInfo,
12938  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12939 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
12940 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12941 
12942  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12943  void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module,
12944  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12946 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12947  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12948  void destroyCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleNV module,
12951 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12952 
12953  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12954  void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV module,
12955  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12957 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12958  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12959  void destroy( VULKAN_HPP_NAMESPACE::CudaModuleNV module,
12962 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12963 
12964  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12965  void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV function,
12966  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12968 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12969  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12970  void destroyCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionNV function,
12973 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12974 
12975  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12976  void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV function,
12977  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12979 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12980  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12981  void destroy( VULKAN_HPP_NAMESPACE::CudaFunctionNV function,
12984 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
12985 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
12986 
12987 #if defined( VK_USE_PLATFORM_METAL_EXT )
12988  //=== VK_EXT_metal_objects ===
12989 
12990  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12991  void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT * pMetalObjectsInfo,
12993 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12994  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12995  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT
12996  exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12997  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12998  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
12999  exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13000 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13001 #endif /*VK_USE_PLATFORM_METAL_EXT*/
13002 
13003  //=== VK_EXT_descriptor_buffer ===
13004 
13005  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13006  void getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13007  VULKAN_HPP_NAMESPACE::DeviceSize * pLayoutSizeInBytes,
13009 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13010  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13012  getDescriptorSetLayoutSizeEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13014 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13015 
13016  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13017  void getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13018  uint32_t binding,
13021 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13022  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13024  getDescriptorSetLayoutBindingOffsetEXT( VULKAN_HPP_NAMESPACE::DescriptorSetLayout layout,
13025  uint32_t binding,
13027 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13028 
13029  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13030  void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT * pDescriptorInfo,
13031  size_t dataSize,
13032  void * pDescriptor,
13034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13035  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13036  void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
13037  size_t dataSize,
13038  void * pDescriptor,
13040  template <typename DescriptorType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13041  VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
13043 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13044 
13045  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13047  getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT * pInfo,
13048  void * pData,
13050 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13051  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13053  getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info,
13054  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13055 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13056 
13057  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13058  VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT * pInfo,
13059  void * pData,
13061 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13062  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13064  getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info,
13065  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13066 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13067 
13068  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13070  getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT * pInfo,
13071  void * pData,
13073 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13074  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13076  getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info,
13077  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13078 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13079 
13080  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13082  getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT * pInfo,
13083  void * pData,
13085 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13086  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13088  getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info,
13089  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13090 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13091 
13092  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13094  getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
13095  void * pData,
13097 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13098  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13100  getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info,
13101  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13102 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13103 
13104  //=== VK_EXT_device_fault ===
13105 
13106  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13107  VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts,
13108  VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT * pFaultInfo,
13110 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13111  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13114 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13115 
13116 #if defined( VK_USE_PLATFORM_FUCHSIA )
13117  //=== VK_FUCHSIA_external_memory ===
13118 
13119  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13120  VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
13121  zx_handle_t * pZirconHandle,
13123 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13124  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13126  getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
13127  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13128 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13129 
13130  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13132  getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
13133  zx_handle_t zirconHandle,
13134  VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
13136 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13137  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13139  getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
13140  zx_handle_t zirconHandle,
13141  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13142 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13143 #endif /*VK_USE_PLATFORM_FUCHSIA*/
13144 
13145 #if defined( VK_USE_PLATFORM_FUCHSIA )
13146  //=== VK_FUCHSIA_external_semaphore ===
13147 
13148  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13150  importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
13152 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13153  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13155  importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
13156  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13157 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13158 
13159  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13160  VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
13161  zx_handle_t * pZirconHandle,
13163 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13164  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13166  getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
13167  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13168 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13169 #endif /*VK_USE_PLATFORM_FUCHSIA*/
13170 
13171 #if defined( VK_USE_PLATFORM_FUCHSIA )
13172  //=== VK_FUCHSIA_buffer_collection ===
13173 
13174  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13175  VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA * pCreateInfo,
13176  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13177  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA * pCollection,
13179 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13180  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13182  createBufferCollectionFUCHSIA( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo,
13184  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13185 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13186  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13188  createBufferCollectionFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA & createInfo,
13190  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13191 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13192 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13193 
13194  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13196  setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13197  const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo,
13199 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13200  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13202  setBufferCollectionImageConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13203  const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo,
13204  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13205 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13206 
13207  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13209  setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13210  const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo,
13212 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13213  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13215  setBufferCollectionBufferConstraintsFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13216  const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo,
13217  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13218 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13219 
13220  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13221  void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13222  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13224 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13225  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13226  void destroyBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13229 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13230 
13231  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13232  void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13233  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13235 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13236  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13237  void destroy( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13240 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13241 
13242  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13243  VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13244  VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA * pProperties,
13246 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13247  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13249  getBufferCollectionPropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection,
13250  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13251 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13252 #endif /*VK_USE_PLATFORM_FUCHSIA*/
13253 
13254  //=== VK_HUAWEI_subpass_shading ===
13255 
13256  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13258  getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,
13259  VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
13261 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13262  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13264  getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13265 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13266 
13267  //=== VK_NV_external_memory_rdma ===
13268 
13269  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13270  VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
13273 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13274  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13276  getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo,
13277  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13278 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13279 
13280  //=== VK_EXT_pipeline_properties ===
13281 
13282  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13284  VULKAN_HPP_NAMESPACE::BaseOutStructure * pPipelineProperties,
13286 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13287  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13290 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13291 
13292  //=== VK_EXT_opacity_micromap ===
13293 
13294  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13295  VULKAN_HPP_NODISCARD Result createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT * pCreateInfo,
13296  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13297  VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromap,
13299 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13300  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13302  createMicromapEXT( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo,
13304  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13305 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13306  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13308  createMicromapEXTUnique( const VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT & createInfo,
13310  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13311 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13312 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13313 
13314  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13315  void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap,
13316  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13318 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13319  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13320  void destroyMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapEXT micromap VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13323 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13324 
13325  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13326  void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap,
13327  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13330  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13331  void destroy( VULKAN_HPP_NAMESPACE::MicromapEXT micromap,
13334 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13335 
13336  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13337  VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13338  uint32_t infoCount,
13339  const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pInfos,
13341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13342  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13344  buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13345  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos,
13346  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13347 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13348 
13349  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13350  VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13351  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT * pInfo,
13353 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13354  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13355  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13356  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info,
13357  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13358 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13359 
13360  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13361  VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13362  const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT * pInfo,
13364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13365  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13366  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13367  const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info,
13368  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13369 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13370 
13371  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13372  VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13373  const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT * pInfo,
13375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13376  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13377  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
13378  const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info,
13379  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13380 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13381 
13382  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13384  const VULKAN_HPP_NAMESPACE::MicromapEXT * pMicromaps,
13386  size_t dataSize,
13387  void * pData,
13388  size_t stride,
13390 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13391  template <typename DataType, typename DataTypeAllocator = std::allocator<DataType>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13393  writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
13395  size_t dataSize,
13396  size_t stride,
13397  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13398  template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13400  writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
13402  size_t stride,
13403  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13404 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13405 
13406  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13407  void getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT * pVersionInfo,
13410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13411  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13413  getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo,
13415 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13416 
13417  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13419  const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT * pBuildInfo,
13420  VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT * pSizeInfo,
13422 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13423  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13424  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT
13426  const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo,
13428 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13429 
13430  //=== VK_EXT_pageable_device_local_memory ===
13431 
13432  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13433  void setMemoryPriorityEXT( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
13434  float priority,
13436 
13437  //=== VK_KHR_maintenance4 ===
13438 
13439  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13440  void getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements * pInfo,
13441  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
13443 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13444  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13445  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13446  getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
13448  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13449  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13450  getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info,
13452 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13453 
13454  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13455  void getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
13456  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
13458 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13459  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13460  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13461  getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
13463  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13464  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13465  getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
13467 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13468 
13469  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13470  void getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements * pInfo,
13471  uint32_t * pSparseMemoryRequirementCount,
13472  VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 * pSparseMemoryRequirements,
13474 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13475  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
13476  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13477  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
13478  getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
13479  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13480  template <typename SparseImageMemoryRequirements2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>,
13481  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13482  typename std::enable_if<
13483  std::is_same<typename SparseImageMemoryRequirements2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>::value,
13484  int>::type = 0>
13485  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
13486  getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info,
13487  SparseImageMemoryRequirements2Allocator & sparseImageMemoryRequirements2Allocator,
13488  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13489 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13490 
13491  //=== VK_VALVE_descriptor_set_host_mapping ===
13492 
13493  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13494  void getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE * pBindingReference,
13495  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping,
13497 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13498  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13499  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE
13500  getDescriptorSetLayoutHostMappingInfoVALVE( const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference,
13502 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13503 
13504  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13505  void getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
13506  void ** ppData,
13508 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13509  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13510  VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( VULKAN_HPP_NAMESPACE::DescriptorSet descriptorSet,
13512 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13513 
13514  //=== VK_NV_device_generated_commands_compute ===
13515 
13516  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13517  void getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfo,
13518  VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
13520 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13521  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13522  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
13523  getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
13525  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13526  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13527  getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
13529 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13530 
13531  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13532  DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV * pInfo,
13534 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13535  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13536  VULKAN_HPP_NAMESPACE::DeviceAddress getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info,
13538 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13539 
13540  //=== VK_EXT_shader_module_identifier ===
13541 
13542  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13543  void getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
13544  VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier,
13546 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13547  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13548  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
13549  getShaderModuleIdentifierEXT( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule,
13551 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13552 
13553  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13554  void getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
13555  VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT * pIdentifier,
13557 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13558  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13559  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
13560  getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo,
13562 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13563 
13564  //=== VK_NV_optical_flow ===
13565 
13566  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13567  VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV * pCreateInfo,
13568  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13569  VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV * pSession,
13571 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13572  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13574  createOpticalFlowSessionNV( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo,
13576  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13577 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13578  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13580  createOpticalFlowSessionNVUnique( const VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV & createInfo,
13582  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13583 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13584 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13585 
13586  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13587  void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
13588  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13590 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13591  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13592  void destroyOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
13595 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13596 
13597  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13598  void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
13599  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13601 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13602  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13603  void destroy( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
13606 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13607 
13608 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
13609  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13610  VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
13612  VULKAN_HPP_NAMESPACE::ImageView view,
13615 #else
13616  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13618  bindOpticalFlowSessionImageNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
13620  VULKAN_HPP_NAMESPACE::ImageView view,
13622  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13623 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13624 
13625  //=== VK_KHR_maintenance5 ===
13626 
13627  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13628  void getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR * pRenderingAreaInfo,
13629  VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
13631 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13632  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13633  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
13634  getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo,
13636 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13637 
13638  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13639  void getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR * pInfo,
13640  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout,
13642 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13643  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13644  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
13645  getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info,
13647  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13648  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13649  getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info,
13651 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13652 
13653  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13654  void getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image,
13655  const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR * pSubresource,
13656  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR * pLayout,
13658 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13659  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13660  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
13661  getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image,
13662  const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
13664  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13665  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13666  getImageSubresourceLayout2KHR( VULKAN_HPP_NAMESPACE::Image image,
13667  const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource,
13669 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13670 
13671  //=== VK_EXT_shader_object ===
13672 
13673  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13674  VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t createInfoCount,
13675  const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos,
13676  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13677  VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders,
13679 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13680  template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13682  createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
13684  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13685  template <typename ShaderEXTAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ShaderEXT>,
13686  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13687  typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, VULKAN_HPP_NAMESPACE::ShaderEXT>::value, int>::type = 0>
13689  createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
13691  ShaderEXTAllocator & shaderEXTAllocator,
13692  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13693  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13695  createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo,
13697  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13698 # ifndef VULKAN_HPP_NO_SMART_HANDLE
13699  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13700  typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>>
13702  createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
13704  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13705  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13706  typename ShaderEXTAllocator = std::allocator<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>,
13707  typename std::enable_if<std::is_same<typename ShaderEXTAllocator::value_type, UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderEXT, Dispatch>>::value,
13708  int>::type = 0>
13710  createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
13712  ShaderEXTAllocator & shaderEXTAllocator,
13713  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13714  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13716  createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo,
13718  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13719 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
13720 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13721 
13722  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13723  void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader,
13724  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13726 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13727  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13728  void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader,
13731 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13732 
13733  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13734  void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader,
13735  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13737 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13738  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13739  void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader,
13742 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13743 
13744  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13745  VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader,
13746  size_t * pDataSize,
13747  void * pData,
13749 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13750  template <typename Uint8_tAllocator = std::allocator<uint8_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13752  getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13753  template <typename Uint8_tAllocator = std::allocator<uint8_t>,
13754  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13755  typename std::enable_if<std::is_same<typename Uint8_tAllocator::value_type, uint8_t>::value, int>::type = 0>
13757  VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13758 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13759 
13760  //=== VK_QCOM_tile_properties ===
13761 
13762  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13763  VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
13764  uint32_t * pPropertiesCount,
13765  VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties,
13767 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13768  template <typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
13769  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13771  getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13772  template <
13773  typename TilePropertiesQCOMAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>,
13774  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13775  typename std::enable_if<std::is_same<typename TilePropertiesQCOMAllocator::value_type, VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>::value, int>::type = 0>
13777  getFramebufferTilePropertiesQCOM( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer,
13778  TilePropertiesQCOMAllocator & tilePropertiesQCOMAllocator,
13779  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13780 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13781 
13782  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13783  Result getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo * pRenderingInfo,
13784  VULKAN_HPP_NAMESPACE::TilePropertiesQCOM * pProperties,
13786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13787  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13788  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
13789  getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo,
13791 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13792 
13793  //=== VK_NV_low_latency2 ===
13794 
13795  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13796  VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13797  const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV * pSleepModeInfo,
13799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13800  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13801  typename ResultValueType<void>::type setLatencySleepModeNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13802  const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo,
13803  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13804 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13805 
13806  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13807  VULKAN_HPP_NODISCARD Result latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13808  const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV * pSleepInfo,
13810 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13811  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13812  typename ResultValueType<void>::type latencySleepNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13813  const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo,
13814  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13815 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13816 
13817  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13818  void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13819  const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV * pLatencyMarkerInfo,
13821 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13822  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13823  void setLatencyMarkerNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13824  const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo,
13826 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13827 
13828  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13829  void getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13830  VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV * pLatencyMarkerInfo,
13832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13833  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13834  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV
13835  getLatencyTimingsNV( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
13837 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13838 
13839 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
13840  //=== VK_QNX_external_memory_screen_buffer ===
13841 
13842  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13843  VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer,
13844  VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX * pProperties,
13846 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13847  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13849  getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13850  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13851  VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
13852  getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13853 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13854 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
13855 
13856  //=== VK_KHR_calibrated_timestamps ===
13857 
13858  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13860  const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR * pTimestampInfos,
13861  uint64_t * pTimestamps,
13862  uint64_t * pMaxDeviation,
13864 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13865  template <typename Uint64_tAllocator = std::allocator<uint64_t>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13867  getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
13868  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13869  template <typename Uint64_tAllocator = std::allocator<uint64_t>,
13870  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13871  typename std::enable_if<std::is_same<typename Uint64_tAllocator::value_type, uint64_t>::value, int>::type = 0>
13873  getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos,
13874  Uint64_tAllocator & uint64_tAllocator,
13875  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13876  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13878  getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo,
13879  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13880 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
13881 
13883  {
13884  return m_device;
13885  }
13886 
13887  explicit operator bool() const VULKAN_HPP_NOEXCEPT
13888  {
13889  return m_device != VK_NULL_HANDLE;
13890  }
13891 
13893  {
13894  return m_device == VK_NULL_HANDLE;
13895  }
13896 
13897  private:
13898  VkDevice m_device = {};
13899  };
13900 
13901  template <>
13902  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
13903  {
13904  using Type = VULKAN_HPP_NAMESPACE::Device;
13905  };
13906 
13907  template <>
13908  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
13909  {
13910  using Type = VULKAN_HPP_NAMESPACE::Device;
13911  };
13912 
13913  template <>
13914  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
13915  {
13916  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
13917  };
13918 
13920  {
13921  public:
13924 
13925  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
13927  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
13928 
13929  public:
13931 
13933 
13934  VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {}
13935 
13936 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
13937  DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
13938  {
13939  m_displayModeKHR = displayModeKHR;
13940  return *this;
13941  }
13942 #endif
13943 
13945  {
13946  m_displayModeKHR = {};
13947  return *this;
13948  }
13949 
13950 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
13951  auto operator<=>( DisplayModeKHR const & ) const = default;
13952 #else
13954  {
13955  return m_displayModeKHR == rhs.m_displayModeKHR;
13956  }
13957 
13959  {
13960  return m_displayModeKHR != rhs.m_displayModeKHR;
13961  }
13962 
13964  {
13965  return m_displayModeKHR < rhs.m_displayModeKHR;
13966  }
13967 #endif
13968 
13970  {
13971  return m_displayModeKHR;
13972  }
13973 
13974  explicit operator bool() const VULKAN_HPP_NOEXCEPT
13975  {
13976  return m_displayModeKHR != VK_NULL_HANDLE;
13977  }
13978 
13980  {
13981  return m_displayModeKHR == VK_NULL_HANDLE;
13982  }
13983 
13984  private:
13985  VkDisplayModeKHR m_displayModeKHR = {};
13986  };
13987 
13988  template <>
13989  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
13990  {
13991  using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
13992  };
13993 
13994  template <>
13995  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
13996  {
13997  using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
13998  };
13999 
14000  template <>
14001  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
14002  {
14003  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
14004  };
14005 
14007  {
14008  public:
14011 
14012  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
14014  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
14015 
14016  public:
14018 
14020 
14021  PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {}
14022 
14024  {
14025  m_physicalDevice = physicalDevice;
14026  return *this;
14027  }
14028 
14030  {
14031  m_physicalDevice = {};
14032  return *this;
14033  }
14034 
14035 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
14036  auto operator<=>( PhysicalDevice const & ) const = default;
14037 #else
14039  {
14040  return m_physicalDevice == rhs.m_physicalDevice;
14041  }
14042 
14044  {
14045  return m_physicalDevice != rhs.m_physicalDevice;
14046  }
14047 
14049  {
14050  return m_physicalDevice < rhs.m_physicalDevice;
14051  }
14052 #endif
14053 
14054  //=== VK_VERSION_1_0 ===
14055 
14056  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14057  void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
14059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14060  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14061  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
14063 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14064 
14065  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14067  VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
14069 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14070  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14071  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
14073 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14074 
14075  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14081  VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
14083 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14084  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14091  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14092 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14093 
14094  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14095  void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
14097 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14098  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14099  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
14101 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14102 
14103  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14104  void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount,
14105  VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
14107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14108  template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
14109  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14110  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
14112  template <typename QueueFamilyPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>,
14113  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14114  typename std::enable_if<std::is_same<typename QueueFamilyPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties>::value,
14115  int>::type = 0>
14116  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties, QueueFamilyPropertiesAllocator>
14117  getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
14118  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14119 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14120 
14121  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14122  void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
14124 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14125  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14126  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
14128 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14129 
14130  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14131  VULKAN_HPP_NODISCARD Result createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo * pCreateInfo,
14132  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14133  VULKAN_HPP_NAMESPACE::Device * pDevice,
14135 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14136  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14138  createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo,
14140  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14141 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14142  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14144  createDeviceUnique( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo & createInfo,
14146  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14147 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14148 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14149 
14150  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14152  uint32_t * pPropertyCount,
14153  VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
14155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14156  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
14157  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14160  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14161  template <
14162  typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
14163  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14164  typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
14167  ExtensionPropertiesAllocator & extensionPropertiesAllocator,
14168  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14169 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14170 
14171  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14173  VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
14175 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14176  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14179  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
14180  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14181  typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
14183  enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14184 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14185 
14186  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14192  uint32_t * pPropertyCount,
14193  VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
14195 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14196  template <typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
14197  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14198  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
14204  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14205  template <
14206  typename SparseImageFormatPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>,
14207  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14208  typename std::enable_if<std::is_same<typename SparseImageFormatPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>::value,
14209  int>::type = 0>
14210  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
14216  SparseImageFormatPropertiesAllocator & sparseImageFormatPropertiesAllocator,
14217  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14218 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14219 
14220  //=== VK_VERSION_1_1 ===
14221 
14222  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14223  void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
14225 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14226  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14227  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
14229  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14230  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14232 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14233 
14234  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14235  void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
14237 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14238  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14239  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
14241  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14242  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14244 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14245 
14246  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14248  VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
14250 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14251  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14252  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
14254  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14255  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14257 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14258 
14259  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14260  VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
14261  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties,
14263 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14264  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14266  getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14267  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14268  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14269  VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14270  getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14271  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14272 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14273 
14274  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14275  void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount,
14276  VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
14278 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14279  template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14280  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14281  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14283  template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14284  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14285  typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,
14286  int>::type = 0>
14287  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14288  getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
14289  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14290  template <typename StructureChain,
14291  typename StructureChainAllocator = std::allocator<StructureChain>,
14292  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14293  VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14295  template <typename StructureChain,
14296  typename StructureChainAllocator = std::allocator<StructureChain>,
14297  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14298  typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
14299  VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14300  getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14301 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14302 
14303  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14304  void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
14306 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14307  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14308  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
14310  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14311  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14313 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14314 
14315  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14316  void getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
14317  uint32_t * pPropertyCount,
14318  VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties,
14320 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14321  template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14322  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14323  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14324  getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14325  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14326  template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14327  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14328  typename std::enable_if<
14329  std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
14330  int>::type = 0>
14331  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14332  getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14333  SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
14334  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14335 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14336 
14337  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14338  void getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
14339  VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties,
14341 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14342  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14343  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
14344  getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
14346 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14347 
14348  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14349  void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
14350  VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
14352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14353  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14354  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
14355  getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
14357 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14358 
14359  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14360  void getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
14361  VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties,
14363 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14364  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14365  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
14366  getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
14368 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14369 
14370  //=== VK_VERSION_1_3 ===
14371 
14372  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14374  VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,
14376 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14377  template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
14378  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14381  template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
14382  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14383  typename std::enable_if<
14384  std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
14385  int>::type = 0>
14387  getToolProperties( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
14388  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14389 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14390 
14391  //=== VK_KHR_surface ===
14392 
14393  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14395  VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14396  VULKAN_HPP_NAMESPACE::Bool32 * pSupported,
14398 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14399  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14401  uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14402 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14403 
14404  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14405  VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14406  VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
14408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14409  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14411  getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14412 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14413 
14414  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14415  VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14416  uint32_t * pSurfaceFormatCount,
14417  VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
14419 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14420  template <typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
14421  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14423  getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14424  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14425  template <
14426  typename SurfaceFormatKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>,
14427  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14428  typename std::enable_if<std::is_same<typename SurfaceFormatKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>::value, int>::type = 0>
14430  getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14431  SurfaceFormatKHRAllocator & surfaceFormatKHRAllocator,
14432  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14433 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14434 
14435  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14436  VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14437  uint32_t * pPresentModeCount,
14438  VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
14440 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14441  template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14443  getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
14444  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14445  template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
14446  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14447  typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
14449  getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14450  PresentModeKHRAllocator & presentModeKHRAllocator,
14451  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14452 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14453 
14454  //=== VK_KHR_swapchain ===
14455 
14456  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14457  VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14458  uint32_t * pRectCount,
14459  VULKAN_HPP_NAMESPACE::Rect2D * pRects,
14461 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14462  template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14464  getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14465  template <typename Rect2DAllocator = std::allocator<VULKAN_HPP_NAMESPACE::Rect2D>,
14466  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14467  typename std::enable_if<std::is_same<typename Rect2DAllocator::value_type, VULKAN_HPP_NAMESPACE::Rect2D>::value, int>::type = 0>
14469  VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Rect2DAllocator & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14470 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14471 
14472  //=== VK_KHR_display ===
14473 
14474  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14476  VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
14478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14479  template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
14480  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14483  template <typename DisplayPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>,
14484  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14485  typename std::enable_if<std::is_same<typename DisplayPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>::value,
14486  int>::type = 0>
14488  getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
14489  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14490 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14491 
14492  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14494  VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
14496 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14497  template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
14498  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14501  template <
14502  typename DisplayPlanePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>,
14503  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14504  typename std::enable_if<std::is_same<typename DisplayPlanePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>::value,
14505  int>::type = 0>
14507  getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
14508  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14509 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14510 
14511  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14513  uint32_t * pDisplayCount,
14514  VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
14516 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14517  template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14519  getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14520  template <typename DisplayKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayKHR>,
14521  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14522  typename std::enable_if<std::is_same<typename DisplayKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayKHR>::value, int>::type = 0>
14524  uint32_t planeIndex, DisplayKHRAllocator & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14525 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14526 
14527  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14528  VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
14529  uint32_t * pPropertyCount,
14530  VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
14532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14533  template <typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
14534  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14536  getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14537  template <
14538  typename DisplayModePropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>,
14539  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14540  typename std::enable_if<std::is_same<typename DisplayModePropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>::value,
14541  int>::type = 0>
14543  getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
14544  DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
14545  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14546 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14547 
14548  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14549  VULKAN_HPP_NODISCARD Result createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
14550  const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
14551  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
14552  VULKAN_HPP_NAMESPACE::DisplayModeKHR * pMode,
14554 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14555  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14557  createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
14558  const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo,
14560  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14561 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14562  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14564  createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR display,
14565  const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR & createInfo,
14567  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14568 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14569 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14570 
14571  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14572  VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
14573  uint32_t planeIndex,
14574  VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
14576 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14577  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14579  VULKAN_HPP_NAMESPACE::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14580 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14581 
14582 #if defined( VK_USE_PLATFORM_XLIB_KHR )
14583  //=== VK_KHR_xlib_surface ===
14584 
14585  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14586  Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
14587  Display * dpy,
14588  VisualID visualID,
14590 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14591  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14592  VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex,
14593  Display & dpy,
14594  VisualID visualID,
14596 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14597 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
14598 
14599 #if defined( VK_USE_PLATFORM_XCB_KHR )
14600  //=== VK_KHR_xcb_surface ===
14601 
14602  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14603  Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
14604  xcb_connection_t * connection,
14605  xcb_visualid_t visual_id,
14607 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14608  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14609  VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex,
14610  xcb_connection_t & connection,
14611  xcb_visualid_t visual_id,
14613 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14614 #endif /*VK_USE_PLATFORM_XCB_KHR*/
14615 
14616 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
14617  //=== VK_KHR_wayland_surface ===
14618 
14619  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14620  Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
14621  struct wl_display * display,
14623 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14624  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14625  VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
14626  struct wl_display & display,
14628 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14629 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
14630 
14631 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14632  //=== VK_KHR_win32_surface ===
14633 
14634  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14635  Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14636 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14637 
14638  //=== VK_KHR_video_queue ===
14639 
14640  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14641  VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR * pVideoProfile,
14642  VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR * pCapabilities,
14644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14645  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14647  getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
14648  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14649  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14650  VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14651  getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile,
14652  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14653 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14654 
14655  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14656  VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
14657  uint32_t * pVideoFormatPropertyCount,
14658  VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR * pVideoFormatProperties,
14660 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14661  template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
14662  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14664  getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
14665  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14666  template <
14667  typename VideoFormatPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>,
14668  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14669  typename std::enable_if<std::is_same<typename VideoFormatPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>::value,
14670  int>::type = 0>
14672  getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
14673  VideoFormatPropertiesKHRAllocator & videoFormatPropertiesKHRAllocator,
14674  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14675 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14676 
14677  //=== VK_NV_external_memory_capabilities ===
14678 
14679  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14686  VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
14688 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14689  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14697  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14698 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14699 
14700  //=== VK_KHR_get_physical_device_properties2 ===
14701 
14702  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14703  void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
14705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14706  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14707  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
14709  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14710  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14712 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14713 
14714  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14715  void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
14717 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14718  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14719  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
14721  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14722  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14724 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14725 
14726  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14728  VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
14730 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14731  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14732  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
14734  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14735  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14737 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14738 
14739  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14740  VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
14741  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 * pImageFormatProperties,
14743 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14744  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14746  getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14747  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14748  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14749  VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14750  getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
14751  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14752 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14753 
14754  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14755  void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount,
14756  VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
14758 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14759  template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14760  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14761  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14763  template <typename QueueFamilyProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>,
14764  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14765  typename std::enable_if<std::is_same<typename QueueFamilyProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>::value,
14766  int>::type = 0>
14767  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2, QueueFamilyProperties2Allocator>
14768  getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
14769  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14770  template <typename StructureChain,
14771  typename StructureChainAllocator = std::allocator<StructureChain>,
14772  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14773  VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14775  template <typename StructureChain,
14776  typename StructureChainAllocator = std::allocator<StructureChain>,
14777  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14778  typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
14779  VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
14780  getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14781 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14782 
14783  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14784  void getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
14786 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14787  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14788  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
14790  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14791  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14793 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14794 
14795  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14796  void getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
14797  uint32_t * pPropertyCount,
14798  VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 * pProperties,
14800 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14801  template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14802  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14803  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14804  getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14805  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14806  template <typename SparseImageFormatProperties2Allocator = std::allocator<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>,
14807  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14808  typename std::enable_if<
14809  std::is_same<typename SparseImageFormatProperties2Allocator::value_type, VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>::value,
14810  int>::type = 0>
14811  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
14812  getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
14813  SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
14814  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14815 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14816 
14817  //=== VK_KHR_external_memory_capabilities ===
14818 
14819  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14820  void getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
14821  VULKAN_HPP_NAMESPACE::ExternalBufferProperties * pExternalBufferProperties,
14823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14824  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14825  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
14826  getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo,
14828 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14829 
14830  //=== VK_KHR_external_semaphore_capabilities ===
14831 
14832  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14833  void getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
14834  VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties * pExternalSemaphoreProperties,
14836 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14837  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14838  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties
14839  getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
14841 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14842 
14843  //=== VK_EXT_direct_mode_display ===
14844 
14845 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
14846  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14847  Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14848 #else
14849  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14850  void releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
14851 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
14852 
14853 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
14854  //=== VK_EXT_acquire_xlib_display ===
14855 
14856  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14857  VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy,
14858  VULKAN_HPP_NAMESPACE::DisplayKHR display,
14860 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14861  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14863  acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14864 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14865 
14866  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14867  VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy,
14868  RROutput rrOutput,
14869  VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
14871 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14872  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14874  getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14875 # ifndef VULKAN_HPP_NO_SMART_HANDLE
14876  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14878  getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14879 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
14880 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14881 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
14882 
14883  //=== VK_EXT_display_surface_counter ===
14884 
14885  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14886  VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
14887  VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
14889 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14890  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14892  getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14893 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14894 
14895  //=== VK_KHR_external_fence_capabilities ===
14896 
14897  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14898  void getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
14899  VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
14901 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14902  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14903  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
14904  getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo,
14906 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14907 
14908  //=== VK_KHR_performance_query ===
14909 
14910  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14913  uint32_t * pCounterCount,
14914  VULKAN_HPP_NAMESPACE::PerformanceCounterKHR * pCounters,
14915  VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
14917 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14918  template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
14919  typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
14920  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14923  std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
14925  template <typename PerformanceCounterKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>,
14926  typename PerformanceCounterDescriptionKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>,
14927  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14928  typename std::enable_if<
14929  std::is_same<typename PerformanceCounterKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>::value &&
14930  std::is_same<typename PerformanceCounterDescriptionKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>::value,
14931  int>::type = 0>
14934  std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
14936  PerformanceCounterKHRAllocator & performanceCounterKHRAllocator,
14937  PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
14938  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14939 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14940 
14941  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14942  void getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
14943  uint32_t * pNumPasses,
14945 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14946  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14947  VULKAN_HPP_NODISCARD uint32_t
14948  getQueueFamilyPerformanceQueryPassesKHR( const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
14950 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14951 
14952  //=== VK_KHR_get_surface_capabilities2 ===
14953 
14954  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14955  VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
14956  VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR * pSurfaceCapabilities,
14958 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14959  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14961  getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14962  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14963  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14964  VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
14965  getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14966  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14967 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
14968 
14969  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14970  VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
14971  uint32_t * pSurfaceFormatCount,
14972  VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR * pSurfaceFormats,
14974 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
14975  template <typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
14976  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14978  getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14979  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14980  template <
14981  typename SurfaceFormat2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>,
14982  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14983  typename std::enable_if<std::is_same<typename SurfaceFormat2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>::value, int>::type = 0>
14985  getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14986  SurfaceFormat2KHRAllocator & surfaceFormat2KHRAllocator,
14987  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14988  template <typename StructureChain,
14989  typename StructureChainAllocator = std::allocator<StructureChain>,
14990  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
14992  getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
14993  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
14994  template <typename StructureChain,
14995  typename StructureChainAllocator = std::allocator<StructureChain>,
14996  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
14997  typename std::enable_if<std::is_same<typename StructureChainAllocator::value_type, StructureChain>::value, int>::type = 0>
14999  getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15000  StructureChainAllocator & structureChainAllocator,
15001  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15002 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15003 
15004  //=== VK_KHR_get_display_properties2 ===
15005 
15006  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15008  VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
15010 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15011  template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
15012  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15015  template <typename DisplayProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>,
15016  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15017  typename std::enable_if<std::is_same<typename DisplayProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>::value,
15018  int>::type = 0>
15020  getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
15021  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15022 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15023 
15024  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15026  VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
15028 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15029  template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
15030  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15033  template <
15034  typename DisplayPlaneProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>,
15035  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15036  typename std::enable_if<std::is_same<typename DisplayPlaneProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>::value,
15037  int>::type = 0>
15039  getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
15040  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15041 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15042 
15043  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15044  VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
15045  uint32_t * pPropertyCount,
15046  VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
15048 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15049  template <typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
15050  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15052  getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15053  template <
15054  typename DisplayModeProperties2KHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>,
15055  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15056  typename std::enable_if<std::is_same<typename DisplayModeProperties2KHRAllocator::value_type, VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>::value,
15057  int>::type = 0>
15059  getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
15060  DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
15061  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15062 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15063 
15064  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15065  VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR * pDisplayPlaneInfo,
15066  VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
15068 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15069  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15071  getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo,
15072  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15073 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15074 
15075  //=== VK_EXT_sample_locations ===
15076 
15077  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15079  VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
15081 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15082  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15083  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
15086 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15087 
15088  //=== VK_EXT_calibrated_timestamps ===
15089 
15090  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15092  VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
15094 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15095  template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15098  template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
15099  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15100  typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
15102  getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15103 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15104 
15105  //=== VK_KHR_fragment_shading_rate ===
15106 
15107  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15108  VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount,
15109  VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
15111 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15112  template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
15113  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15117  template <typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>,
15118  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15119  typename std::enable_if<std::is_same<typename PhysicalDeviceFragmentShadingRateKHRAllocator::value_type,
15120  VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>::value,
15121  int>::type = 0>
15124  getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
15125  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15126 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15127 
15128  //=== VK_EXT_tooling_info ===
15129 
15130  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15132  VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties * pToolProperties,
15134 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15135  template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
15136  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15139  template <typename PhysicalDeviceToolPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>,
15140  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15141  typename std::enable_if<
15142  std::is_same<typename PhysicalDeviceToolPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>::value,
15143  int>::type = 0>
15145  getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator & physicalDeviceToolPropertiesAllocator,
15146  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15147 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15148 
15149  //=== VK_NV_cooperative_matrix ===
15150 
15151  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15153  VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
15155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15156  template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
15157  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15161  template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>,
15162  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15163  typename std::enable_if<
15164  std::is_same<typename CooperativeMatrixPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>::value,
15165  int>::type = 0>
15168  getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
15169  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15170 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15171 
15172  //=== VK_NV_coverage_reduction_mode ===
15173 
15174  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15177  VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
15179 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15180  template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
15181  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15185  template <typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>,
15186  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15187  typename std::enable_if<std::is_same<typename FramebufferMixedSamplesCombinationNVAllocator::value_type,
15188  VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>::value,
15189  int>::type = 0>
15192  getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
15193  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15194 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15195 
15196 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15197  //=== VK_EXT_full_screen_exclusive ===
15198 
15199  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15200  VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
15201  uint32_t * pPresentModeCount,
15202  VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
15204 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15205  template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15207  getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15208  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15209  template <typename PresentModeKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PresentModeKHR>,
15210  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15211  typename std::enable_if<std::is_same<typename PresentModeKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::PresentModeKHR>::value, int>::type = 0>
15213  getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
15214  PresentModeKHRAllocator & presentModeKHRAllocator,
15215  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15216 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15217 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15218 
15219  //=== VK_EXT_acquire_drm_display ===
15220 
15221 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15222  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15223  VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t drmFd,
15224  VULKAN_HPP_NAMESPACE::DisplayKHR display,
15226 #else
15227  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15229  acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15230 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15231 
15232  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15234  uint32_t connectorId,
15235  VULKAN_HPP_NAMESPACE::DisplayKHR * display,
15237 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15238  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15240  getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15241 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15242  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15244  getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15245 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15246 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15247 
15248  //=== VK_KHR_video_encode_queue ===
15249 
15250  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15252  getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
15253  VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties,
15255 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15256  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15258  getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
15259  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15260  template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15261  VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>>::type
15262  getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo,
15263  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15264 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15265 
15266 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15267  //=== VK_NV_acquire_winrt_display ===
15268 
15269 # ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
15270  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15271  VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
15273 # else
15274  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15276  acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15277 # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
15278 
15279  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15280  VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId,
15281  VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
15283 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15284  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15286  getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15287 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15288  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15290  getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15291 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15292 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15293 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15294 
15295 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
15296  //=== VK_EXT_directfb_surface ===
15297 
15298  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15299  Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
15300  IDirectFB * dfb,
15302 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15303  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15304  VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
15305  IDirectFB & dfb,
15307 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15308 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
15309 
15310 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
15311  //=== VK_QNX_screen_surface ===
15312 
15313  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15314  Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
15315  struct _screen_window * window,
15317 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15318  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15319  VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
15320  struct _screen_window & window,
15322 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15323 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
15324 
15325  //=== VK_NV_optical_flow ===
15326 
15327  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15328  VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
15329  uint32_t * pFormatCount,
15330  VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV * pImageFormatProperties,
15332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15333  template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
15334  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15337  getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
15338  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15339  template <typename OpticalFlowImageFormatPropertiesNVAllocator = std::allocator<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>,
15340  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15341  typename std::enable_if<
15342  std::is_same<typename OpticalFlowImageFormatPropertiesNVAllocator::value_type, VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>::value,
15343  int>::type = 0>
15346  getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo,
15347  OpticalFlowImageFormatPropertiesNVAllocator & opticalFlowImageFormatPropertiesNVAllocator,
15348  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15349 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15350 
15351  //=== VK_KHR_cooperative_matrix ===
15352 
15353  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15355  VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR * pProperties,
15357 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15358  template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
15359  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15363  template <typename CooperativeMatrixPropertiesKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>,
15364  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15365  typename std::enable_if<
15366  std::is_same<typename CooperativeMatrixPropertiesKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>::value,
15367  int>::type = 0>
15370  getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator & cooperativeMatrixPropertiesKHRAllocator,
15371  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15372 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15373 
15374  //=== VK_KHR_calibrated_timestamps ===
15375 
15376  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15378  VULKAN_HPP_NAMESPACE::TimeDomainKHR * pTimeDomains,
15380 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15381  template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15384  template <typename TimeDomainKHRAllocator = std::allocator<VULKAN_HPP_NAMESPACE::TimeDomainKHR>,
15385  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15386  typename std::enable_if<std::is_same<typename TimeDomainKHRAllocator::value_type, VULKAN_HPP_NAMESPACE::TimeDomainKHR>::value, int>::type = 0>
15388  getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator & timeDomainKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15389 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15390 
15392  {
15393  return m_physicalDevice;
15394  }
15395 
15396  explicit operator bool() const VULKAN_HPP_NOEXCEPT
15397  {
15398  return m_physicalDevice != VK_NULL_HANDLE;
15399  }
15400 
15402  {
15403  return m_physicalDevice == VK_NULL_HANDLE;
15404  }
15405 
15406  private:
15407  VkPhysicalDevice m_physicalDevice = {};
15408  };
15409 
15410  template <>
15411  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
15412  {
15413  using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
15414  };
15415 
15416  template <>
15417  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
15418  {
15419  using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
15420  };
15421 
15422  template <>
15423  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
15424  {
15425  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
15426  };
15427 
15428  class Instance
15429  {
15430  public:
15433 
15434  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
15436  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
15437 
15438  public:
15440 
15442 
15443  Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
15444 
15446  {
15447  m_instance = instance;
15448  return *this;
15449  }
15450 
15452  {
15453  m_instance = {};
15454  return *this;
15455  }
15456 
15457 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
15458  auto operator<=>( Instance const & ) const = default;
15459 #else
15460  bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
15461  {
15462  return m_instance == rhs.m_instance;
15463  }
15464 
15465  bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
15466  {
15467  return m_instance != rhs.m_instance;
15468  }
15469 
15470  bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
15471  {
15472  return m_instance < rhs.m_instance;
15473  }
15474 #endif
15475 
15476  //=== VK_VERSION_1_0 ===
15477 
15478  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15479  void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15481 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15482  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15485 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15486 
15487  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15488  VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount,
15489  VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
15491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15492  template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15495  template <typename PhysicalDeviceAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDevice>,
15496  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15497  typename std::enable_if<std::is_same<typename PhysicalDeviceAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDevice>::value, int>::type = 0>
15499  enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15500 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15501 
15502  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15504 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15505  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15507 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15508 
15509  //=== VK_VERSION_1_1 ===
15510 
15511  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15512  VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount,
15513  VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
15515 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15516  template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
15517  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15521  template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
15522  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15523  typename std::enable_if<
15524  std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
15525  int>::type = 0>
15528  enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
15529  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15530 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15531 
15532  //=== VK_KHR_surface ===
15533 
15534  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15535  void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
15536  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15539  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15540  void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15543 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15544 
15545  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15546  void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
15547  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15550  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15551  void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
15554 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15555 
15556  //=== VK_KHR_display ===
15557 
15558  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15559  VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
15560  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15561  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15564  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15566  createDisplayPlaneSurfaceKHR( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo,
15568  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15569 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15570  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15572  createDisplayPlaneSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR & createInfo,
15574  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15575 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15576 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15577 
15578 #if defined( VK_USE_PLATFORM_XLIB_KHR )
15579  //=== VK_KHR_xlib_surface ===
15580 
15581  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15582  VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
15583  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15584  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15586 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15587  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15589  createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo,
15591  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15592 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15593  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15595  createXlibSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR & createInfo,
15597  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15598 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15599 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15600 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
15601 
15602 #if defined( VK_USE_PLATFORM_XCB_KHR )
15603  //=== VK_KHR_xcb_surface ===
15604 
15605  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15606  VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
15607  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15608  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15610 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15611  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15613  createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo,
15615  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15616 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15617  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15619  createXcbSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR & createInfo,
15621  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15622 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15623 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15624 #endif /*VK_USE_PLATFORM_XCB_KHR*/
15625 
15626 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
15627  //=== VK_KHR_wayland_surface ===
15628 
15629  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15630  VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
15631  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15632  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15634 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15635  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15637  createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo,
15639  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15640 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15641  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15643  createWaylandSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR & createInfo,
15645  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15646 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15647 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15648 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
15649 
15650 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
15651  //=== VK_KHR_android_surface ===
15652 
15653  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15654  VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
15655  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15656  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15658 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15659  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15661  createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo,
15663  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15664 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15665  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15667  createAndroidSurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR & createInfo,
15669  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15670 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15671 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15672 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
15673 
15674 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15675  //=== VK_KHR_win32_surface ===
15676 
15677  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15678  VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
15679  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15680  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15682 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15683  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15685  createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo,
15687  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15688 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15689  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15691  createWin32SurfaceKHRUnique( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR & createInfo,
15693  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15694 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15695 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15696 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15697 
15698  //=== VK_EXT_debug_report ===
15699 
15700  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15701  VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
15702  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15703  VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT * pCallback,
15705 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15706  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15708  createDebugReportCallbackEXT( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo,
15710  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15711 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15712  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15714  createDebugReportCallbackEXTUnique( const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT & createInfo,
15716  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15717 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15718 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15719 
15720  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15721  void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
15722  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15724 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15725  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15726  void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15729 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15730 
15731  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15732  void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
15733  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15735 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15736  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15737  void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
15740 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15741 
15742  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15745  uint64_t object,
15746  size_t location,
15747  int32_t messageCode,
15748  const char * pLayerPrefix,
15749  const char * pMessage,
15751 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15752  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15755  uint64_t object,
15756  size_t location,
15757  int32_t messageCode,
15758  const std::string & layerPrefix,
15759  const std::string & message,
15761 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15762 
15763 #if defined( VK_USE_PLATFORM_GGP )
15764  //=== VK_GGP_stream_descriptor_surface ===
15765 
15766  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15767  VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
15768  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15769  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15771 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15772  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15774  createStreamDescriptorSurfaceGGP( const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo,
15776  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15777 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15778  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15779  VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createStreamDescriptorSurfaceGGPUnique(
15780  const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP & createInfo,
15782  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15783 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15784 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15785 #endif /*VK_USE_PLATFORM_GGP*/
15786 
15787 #if defined( VK_USE_PLATFORM_VI_NN )
15788  //=== VK_NN_vi_surface ===
15789 
15790  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15791  VULKAN_HPP_NODISCARD Result createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
15792  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15793  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15795 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15796  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15798  createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo,
15800  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15801 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15802  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15804  createViSurfaceNNUnique( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN & createInfo,
15806  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15807 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15808 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15809 #endif /*VK_USE_PLATFORM_VI_NN*/
15810 
15811  //=== VK_KHR_device_group_creation ===
15812 
15813  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15814  VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount,
15815  VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
15817 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15818  template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
15819  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15823  template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>,
15824  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
15825  typename std::enable_if<
15826  std::is_same<typename PhysicalDeviceGroupPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>::value,
15827  int>::type = 0>
15830  enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
15831  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15832 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15833 
15834 #if defined( VK_USE_PLATFORM_IOS_MVK )
15835  //=== VK_MVK_ios_surface ===
15836 
15837  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15838  VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
15839  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15840  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15842 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15843  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15845  createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo,
15847  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15848 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15849  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15851  createIOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK & createInfo,
15853  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15854 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15855 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15856 #endif /*VK_USE_PLATFORM_IOS_MVK*/
15857 
15858 #if defined( VK_USE_PLATFORM_MACOS_MVK )
15859  //=== VK_MVK_macos_surface ===
15860 
15861  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15862  VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
15863  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15864  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15866 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15867  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15869  createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo,
15871  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15872 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15873  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15875  createMacOSSurfaceMVKUnique( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK & createInfo,
15877  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15878 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15879 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15880 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
15881 
15882  //=== VK_EXT_debug_utils ===
15883 
15884  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15885  VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
15886  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15887  VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT * pMessenger,
15889 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15890  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15892  createDebugUtilsMessengerEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo,
15894  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15895 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15896  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15898  createDebugUtilsMessengerEXTUnique( const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT & createInfo,
15900  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15901 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15902 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15903 
15904  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15905  void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
15906  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15908 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15909  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15910  void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
15913 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15914 
15915  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15916  void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
15917  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15919 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15920  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15921  void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
15924 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15925 
15926  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15929  const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
15931 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15932  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15935  const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData,
15937 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15938 
15939 #if defined( VK_USE_PLATFORM_FUCHSIA )
15940  //=== VK_FUCHSIA_imagepipe_surface ===
15941 
15942  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15943  VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
15944  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15945  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15947 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15948  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15950  createImagePipeSurfaceFUCHSIA( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
15952  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15953 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15954  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15956  createImagePipeSurfaceFUCHSIAUnique( const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
15958  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15959 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15960 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15961 #endif /*VK_USE_PLATFORM_FUCHSIA*/
15962 
15963 #if defined( VK_USE_PLATFORM_METAL_EXT )
15964  //=== VK_EXT_metal_surface ===
15965 
15966  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15967  VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
15968  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15969  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15971 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15972  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15974  createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo,
15976  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15977 # ifndef VULKAN_HPP_NO_SMART_HANDLE
15978  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15980  createMetalSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT & createInfo,
15982  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
15983 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
15984 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
15985 #endif /*VK_USE_PLATFORM_METAL_EXT*/
15986 
15987  //=== VK_EXT_headless_surface ===
15988 
15989  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15990  VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
15991  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
15992  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
15994 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
15995  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
15997  createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo,
15999  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16000 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16001  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16003  createHeadlessSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT & createInfo,
16005  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16006 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16007 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16008 
16009 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
16010  //=== VK_EXT_directfb_surface ===
16011 
16012  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16013  VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
16014  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16015  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
16017 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16018  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16020  createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo,
16022  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16023 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16024  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16026  createDirectFBSurfaceEXTUnique( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT & createInfo,
16028  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16029 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16030 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16031 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
16032 
16033 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
16034  //=== VK_QNX_screen_surface ===
16035 
16036  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16037  VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
16038  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16039  VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface,
16041 # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16042  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16044  createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo,
16046  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16047 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16048  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16050  createScreenSurfaceQNXUnique( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX & createInfo,
16052  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
16053 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16054 # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16055 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
16056 
16058  {
16059  return m_instance;
16060  }
16061 
16062  explicit operator bool() const VULKAN_HPP_NOEXCEPT
16063  {
16064  return m_instance != VK_NULL_HANDLE;
16065  }
16066 
16068  {
16069  return m_instance == VK_NULL_HANDLE;
16070  }
16071 
16072  private:
16073  VkInstance m_instance = {};
16074  };
16075 
16076  template <>
16077  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
16078  {
16079  using Type = VULKAN_HPP_NAMESPACE::Instance;
16080  };
16081 
16082  template <>
16083  struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
16084  {
16085  using Type = VULKAN_HPP_NAMESPACE::Instance;
16086  };
16087 
16088  template <>
16089  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
16090  {
16091  static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
16092  };
16093 
16094  //=== VK_VERSION_1_0 ===
16095 
16096  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16097  VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo * pCreateInfo,
16098  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
16099  VULKAN_HPP_NAMESPACE::Instance * pInstance,
16101 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16102  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16104  createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo,
16106  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16107 # ifndef VULKAN_HPP_NO_SMART_HANDLE
16108  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16110  createInstanceUnique( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo & createInfo,
16112  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16113 # endif /* VULKAN_HPP_NO_SMART_HANDLE */
16114 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16115 
16116  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16118  uint32_t * pPropertyCount,
16119  VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
16121 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16122  template <typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
16123  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16126  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16127  template <
16128  typename ExtensionPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::ExtensionProperties>,
16129  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16130  typename std::enable_if<std::is_same<typename ExtensionPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::ExtensionProperties>::value, int>::type = 0>
16133  ExtensionPropertiesAllocator & extensionPropertiesAllocator,
16134  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16135 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16136 
16137  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16139  VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
16141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16142  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16145  template <typename LayerPropertiesAllocator = std::allocator<VULKAN_HPP_NAMESPACE::LayerProperties>,
16146  typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
16147  typename std::enable_if<std::is_same<typename LayerPropertiesAllocator::value_type, VULKAN_HPP_NAMESPACE::LayerProperties>::value, int>::type = 0>
16149  enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
16150 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16151 
16152  //=== VK_VERSION_1_1 ===
16153 
16154  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
16158  template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
16160 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
16161 
16162 } // namespace VULKAN_HPP_NAMESPACE
16163 
16164 // operators to compare vk::-handles with nullptr
16165 template <typename T>
16166 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( const T & v, std::nullptr_t )
16167 {
16168  return !v;
16169 }
16170 
16171 template <typename T>
16172 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator==( std::nullptr_t, const T & v )
16173 {
16174  return !v;
16175 }
16176 
16177 template <typename T>
16178 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( const T & v, std::nullptr_t )
16179 {
16180  return v;
16181 }
16182 
16183 template <typename T>
16184 typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, bool>::type operator!=( std::nullptr_t, const T & v )
16185 {
16186  return v;
16187 }
16188 #endif
Definition: vulkan_handles.hpp:4091
VkAccelerationStructureKHR NativeType
Definition: vulkan_handles.hpp:4094
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4103
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4105
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4153
VkAccelerationStructureKHR CType
Definition: vulkan_handles.hpp:4093
bool operator<(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4137
bool operator==(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4127
AccelerationStructureKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4118
VULKAN_HPP_CONSTEXPR AccelerationStructureKHR()=default
bool operator!=(AccelerationStructureKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4132
Definition: vulkan_handles.hpp:3738
VkAccelerationStructureNV NativeType
Definition: vulkan_handles.hpp:3741
bool operator!=(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3779
bool operator==(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3774
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3800
VULKAN_HPP_CONSTEXPR AccelerationStructureNV()=default
VkAccelerationStructureNV CType
Definition: vulkan_handles.hpp:3740
bool operator<(AccelerationStructureNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3784
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3752
VULKAN_HPP_CONSTEXPR AccelerationStructureNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3750
AccelerationStructureNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3765
Definition: vulkan_handles.hpp:6967
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7026
VkBufferView CType
Definition: vulkan_handles.hpp:6969
VULKAN_HPP_TYPESAFE_EXPLICIT BufferView(VkBufferView bufferView) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6981
VULKAN_HPP_CONSTEXPR BufferView(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6979
bool operator<(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7010
VkBufferView NativeType
Definition: vulkan_handles.hpp:6970
bool operator!=(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7005
bool operator==(BufferView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7000
VULKAN_HPP_CONSTEXPR BufferView()=default
BufferView & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6991
Definition: vulkan_handles.hpp:3135
Buffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3159
VULKAN_HPP_CONSTEXPR Buffer()=default
VkBuffer NativeType
Definition: vulkan_handles.hpp:3138
bool operator==(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3168
VULKAN_HPP_CONSTEXPR Buffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3147
bool operator<(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3178
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3194
VkBuffer CType
Definition: vulkan_handles.hpp:3137
bool operator!=(Buffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3173
VULKAN_HPP_TYPESAFE_EXPLICIT Buffer(VkBuffer buffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3149
Definition: vulkan_handles.hpp:4262
void decompressMemoryNV(vk::ArrayProxy< const vk::DecompressMemoryRegionNV > const &decompressMemoryRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissor(uint32_t firstScissor, vk::ArrayProxy< const vk::Rect2D > const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginConditionalRenderingEXT(const vk::ConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawClusterHUAWEI(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorBlendAdvancedEXT(uint32_t firstAttachment, vk::ArrayProxy< const vk::ColorBlendAdvancedEXT > const &colorBlendAdvanced, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void controlVideoCodingKHR(const vk::VideoCodingControlInfoKHR *pCodingControlInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void decompressMemoryNV(uint32_t decompressRegionCount, const vk::DecompressMemoryRegionNV *pDecompressMemoryRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void encodeVideoKHR(const vk::VideoEncodeInfoKHR &encodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksIndirectEXT(vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeMicromapsPropertiesEXT(vk::ArrayProxy< const vk::MicromapEXT > const &micromaps, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void opticalFlowExecuteNV(vk::OpticalFlowSessionNV session, const vk::OpticalFlowExecuteInfoNV &executeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pipelineBarrier(vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, vk::ArrayProxy< const vk::MemoryBarrier > const &memoryBarriers, vk::ArrayProxy< const vk::BufferMemoryBarrier > const &bufferMemoryBarriers, vk::ArrayProxy< const vk::ImageMemoryBarrier > const &imageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushDescriptorSet2KHR(const vk::PushDescriptorSetInfoKHR *pPushDescriptorSetInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setPrimitiveTopology(vk::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBuffer2KHR(const vk::CopyBufferInfo2 &copyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void traceRaysNV(vk::Buffer raygenShaderBindingTableBuffer, vk::DeviceSize raygenShaderBindingOffset, vk::Buffer missShaderBindingTableBuffer, vk::DeviceSize missShaderBindingOffset, vk::DeviceSize missShaderBindingStride, vk::Buffer hitShaderBindingTableBuffer, vk::DeviceSize hitShaderBindingOffset, vk::DeviceSize hitShaderBindingStride, vk::Buffer callableShaderBindingTableBuffer, vk::DeviceSize callableShaderBindingOffset, vk::DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setExclusiveScissorNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const vk::Rect2D *pExclusiveScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndirect(vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthClipNegativeOneToOneEXT(vk::Bool32 negativeOneToOne, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBiasEnableEXT(vk::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRenderPass2KHR(const vk::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBuffer2(const vk::CopyBufferInfo2 &copyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void waitEvents2(uint32_t eventCount, const vk::Event *pEvents, const vk::DependencyInfo *pDependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setExclusiveScissorEnableNV(uint32_t firstExclusiveScissor, vk::ArrayProxy< const vk::Bool32 > const &exclusiveScissorEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorBlendAdvancedEXT(uint32_t firstAttachment, uint32_t attachmentCount, const vk::ColorBlendAdvancedEXT *pColorBlendAdvanced, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void opticalFlowExecuteNV(vk::OpticalFlowSessionNV session, const vk::OpticalFlowExecuteInfoNV *pExecuteInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderPass2(const vk::RenderPassBeginInfo &renderPassBegin, const vk::SubpassBeginInfo &subpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushDescriptorSetWithTemplate2KHR(const vk::PushDescriptorSetWithTemplateInfoKHR *pPushDescriptorSetWithTemplateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void nextSubpass(vk::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
CommandBuffer(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4276
void traceRaysIndirectKHR(const vk::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, vk::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMemoryIndirectNV(vk::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VkCommandBuffer NativeType
Definition: vulkan_handles.hpp:4265
void setLineStippleEXT(uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissorWithCountEXT(vk::ArrayProxy< const vk::Rect2D > const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructuresKHR(vk::ArrayProxy< const vk::AccelerationStructureBuildGeometryInfoKHR > const &infos, vk::ArrayProxy< const vk::AccelerationStructureBuildRangeInfoKHR *const > const &pBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void setPolygonModeEXT(vk::PolygonMode polygonMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissorWithCountEXT(uint32_t scissorCount, const vk::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderingKHR(const vk::RenderingInfo &renderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushConstants2KHR(const vk::PushConstantsInfoKHR &pushConstantsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void copyBufferToImage2(const vk::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImageToBuffer2(const vk::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setEvent2(vk::Event event, const vk::DependencyInfo &dependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void debugMarkerInsertEXT(const vk::DebugMarkerMarkerInfoEXT &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void preprocessGeneratedCommandsNV(const vk::GeneratedCommandsInfoNV *pGeneratedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthTestEnableEXT(vk::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderingKHR(const vk::RenderingInfo *pRenderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportWScalingNV(uint32_t firstViewport, vk::ArrayProxy< const vk::ViewportWScalingNV > const &viewportWScalings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setAlphaToOneEnableEXT(vk::Bool32 alphaToOneEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceStreamMarkerINTEL(const vk::PerformanceStreamMarkerInfoINTEL &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setDepthBias2EXT(const vk::DepthBiasInfoEXT *pDepthBiasInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void subpassShadingHUAWEI(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportWithCountEXT(vk::ArrayProxy< const vk::Viewport > const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndexedIndirect(vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCoverageToColorLocationNV(uint32_t coverageToColorLocation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthCompareOp(vk::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage2KHR(const vk::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBufferToImage2KHR(const vk::CopyBufferToImageInfo2 *pCopyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMultiEXT(vk::StridedArrayProxy< const vk::MultiDrawInfoEXT > const &vertexInfo, uint32_t instanceCount, uint32_t firstInstance, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDescriptorBufferOffsetsEXT(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, vk::ArrayProxy< const uint32_t > const &bufferIndices, vk::ArrayProxy< const vk::DeviceSize > const &offsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void pushDescriptorSetKHR(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, vk::ArrayProxy< const vk::WriteDescriptorSet > const &descriptorWrites, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDeviceMask(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindDescriptorBuffersEXT(vk::ArrayProxy< const vk::DescriptorBufferBindingInfoEXT > const &bindingInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void traceRaysKHR(const vk::StridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pMissShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pHitShaderBindingTable, const vk::StridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setConservativeRasterizationModeEXT(vk::ConservativeRasterizationModeEXT conservativeRasterizationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginVideoCodingKHR(const vk::VideoBeginCodingInfoKHR &beginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setTessellationDomainOriginEXT(vk::TessellationDomainOrigin domainOrigin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructuresIndirectKHR(vk::ArrayProxy< const vk::AccelerationStructureBuildGeometryInfoKHR > const &infos, vk::ArrayProxy< const vk::DeviceAddress > const &indirectDeviceAddresses, vk::ArrayProxy< const uint32_t > const &indirectStrides, vk::ArrayProxy< const uint32_t *const > const &pMaxPrimitiveCounts, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void copyImage2(const vk::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void cudaLaunchKernelNV(const vk::CudaLaunchInfoNV &launchInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchGraphIndirectAMDX(vk::DeviceAddress scratch, const vk::DispatchGraphCountInfoAMDX *pCountInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resolveImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::ImageResolve > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawClusterIndirectHUAWEI(vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setExclusiveScissorEnableNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const vk::Bool32 *pExclusiveScissorEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImageToBuffer(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, vk::ArrayProxy< const vk::BufferImageCopy > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void nextSubpass2KHR(const vk::SubpassBeginInfo &subpassBeginInfo, const vk::SubpassEndInfo &subpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setEvent2KHR(vk::Event event, const vk::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage2(const vk::BlitImageInfo2 *pBlitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type end(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void copyImageToBuffer2KHR(const vk::CopyImageToBufferInfo2 &copyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBounds(float minDepthBounds, float maxDepthBounds, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer *pCounterBuffers, const vk::DeviceSize *pCounterBufferOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorBlendEquationEXT(uint32_t firstAttachment, uint32_t attachmentCount, const vk::ColorBlendEquationEXT *pColorBlendEquations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissorWithCount(uint32_t scissorCount, const vk::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setLogicOpEnableEXT(vk::Bool32 logicOpEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void traceRaysKHR(const vk::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &missShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &hitShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &callableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void encodeVideoKHR(const vk::VideoEncodeInfoKHR *pEncodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
CommandBuffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4284
void drawIndexedIndirectCountAMD(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCoverageReductionModeNV(vk::CoverageReductionModeNV coverageReductionMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthClampEnableEXT(vk::Bool32 depthClampEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void fillBuffer(vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize size, uint32_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, vk::ArrayProxy< const vk::DeviceSize > const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer *pBuffers, const vk::DeviceSize *pOffsets, const vk::DeviceSize *pSizes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void clearDepthStencilImage(vk::Image image, vk::ImageLayout imageLayout, const vk::ClearDepthStencilValue &depthStencil, vk::ArrayProxy< const vk::ImageSubresourceRange > const &ranges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers2(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, vk::ArrayProxy< const vk::DeviceSize > const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, vk::ArrayProxy< const vk::DeviceSize > const &strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void bindDescriptorSets2KHR(const vk::BindDescriptorSetsInfoKHR &bindDescriptorSetsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilOpEXT(vk::StencilFaceFlags faceMask, vk::StencilOp failOp, vk::StencilOp passOp, vk::StencilOp depthFailOp, vk::CompareOp compareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBuffer(vk::Buffer srcBuffer, vk::Buffer dstBuffer, vk::ArrayProxy< const vk::BufferCopy > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBoundsTestEnable(vk::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void waitEvents2KHR(vk::ArrayProxy< const vk::Event > const &events, vk::ArrayProxy< const vk::DependencyInfo > const &dependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void bindDescriptorSets(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const vk::DescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, vk::ArrayProxy< const vk::Buffer > const &counterBuffers, vk::ArrayProxy< const vk::DeviceSize > const &counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void setViewportWScalingEnableNV(vk::Bool32 viewportWScalingEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void waitEvents2KHR(uint32_t eventCount, const vk::Event *pEvents, const vk::DependencyInfo *pDependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceOverrideINTEL(const vk::PerformanceOverrideInfoINTEL &overrideInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setDeviceMaskKHR(uint32_t deviceMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void debugMarkerEndEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBuffer2(const vk::CopyBufferInfo2 *pCopyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginVideoCodingKHR(const vk::VideoBeginCodingInfoKHR *pBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissorWithCount(vk::ArrayProxy< const vk::Rect2D > const &scissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMemoryToImageIndirectNV(vk::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, vk::Image dstImage, vk::ImageLayout dstImageLayout, const vk::ImageSubresourceLayers *pImageSubresources, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructureNV(const vk::AccelerationStructureInfoNV *pInfo, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndirectCountKHR(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImageToBuffer2(const vk::CopyImageToBufferInfo2 &copyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksIndirectNV(vk::Buffer buffer, vk::DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRasterizerDiscardEnableEXT(vk::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void waitEvents(vk::ArrayProxy< const vk::Event > const &events, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::ArrayProxy< const vk::MemoryBarrier > const &memoryBarriers, vk::ArrayProxy< const vk::BufferMemoryBarrier > const &bufferMemoryBarriers, vk::ArrayProxy< const vk::ImageMemoryBarrier > const &imageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void decodeVideoKHR(const vk::VideoDecodeInfoKHR *pDecodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void controlVideoCodingKHR(const vk::VideoCodingControlInfoKHR &codingControlInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setAlphaToCoverageEnableEXT(vk::Bool32 alphaToCoverageEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeTimestamp2(vk::PipelineStageFlags2 stage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void executeCommands(uint32_t commandBufferCount, const vk::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorBlendEquationEXT(uint32_t firstAttachment, vk::ArrayProxy< const vk::ColorBlendEquationEXT > const &colorBlendEquations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setVertexInputEXT(uint32_t vertexBindingDescriptionCount, const vk::VertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const vk::VertexInputAttributeDescription2EXT *pVertexAttributeDescriptions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushDescriptorSetWithTemplate2KHR(const vk::PushDescriptorSetWithTemplateInfoKHR &pushDescriptorSetWithTemplateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderPass(const vk::RenderPassBeginInfo *pRenderPassBegin, vk::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRasterizationStreamEXT(uint32_t rasterizationStream, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorWriteMaskEXT(uint32_t firstAttachment, uint32_t attachmentCount, const vk::ColorComponentFlags *pColorWriteMasks, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setLogicOpEXT(vk::LogicOp logicOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeBufferMarker2AMD(vk::PipelineStageFlags2 stage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pipelineBarrier2KHR(const vk::DependencyInfo &dependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCheckpointNV(const void *pCheckpointMarker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setPrimitiveTopologyEXT(vk::PrimitiveTopology primitiveTopology, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endQuery(vk::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDiscardRectangleEnableEXT(vk::Bool32 discardRectangleEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginConditionalRenderingEXT(const vk::ConditionalRenderingBeginInfoEXT &conditionalRenderingBegin, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setBlendConstants(const float blendConstants[4], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void debugMarkerBeginEXT(const vk::DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushConstants(vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, vk::ArrayProxy< const ValuesType > const &values, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindPipelineShaderGroupNV(vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, uint32_t groupIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4298
void bindDescriptorBufferEmbeddedSamplersEXT(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCullMode(vk::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setAttachmentFeedbackLoopEnableEXT(vk::ImageAspectFlags aspectMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchGraphIndirectAMDX(vk::DeviceAddress scratch, const vk::DispatchGraphCountInfoAMDX &countInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void clearDepthStencilImage(vk::Image image, vk::ImageLayout imageLayout, const vk::ClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const vk::ImageSubresourceRange *pRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void decodeVideoKHR(const vk::VideoDecodeInfoKHR &decodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImageToBuffer(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksIndirectCountEXT(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers2EXT(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, vk::ArrayProxy< const vk::DeviceSize > const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, vk::ArrayProxy< const vk::DeviceSize > const &strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void copyMemoryToImageIndirectNV(vk::DeviceAddress copyBufferAddress, uint32_t stride, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::ImageSubresourceLayers > const &imageSubresources, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeBufferMarkerAMD(vk::PipelineStageFlagBits pipelineStage, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, uint32_t marker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const vk::Rect2D *pDiscardRectangles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endVideoCodingKHR(const vk::VideoEndCodingInfoKHR *pEndCodingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void cuLaunchKernelNVX(const vk::CuLaunchInfoNVX *pLaunchInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyAccelerationStructureToMemoryKHR(const vk::CopyAccelerationStructureToMemoryInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resolveImage2(const vk::ResolveImageInfo2 *pResolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushConstants2KHR(const vk::PushConstantsInfoKHR *pPushConstantsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBoundsTestEnableEXT(vk::Bool32 depthBoundsTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportWithCountEXT(uint32_t viewportCount, const vk::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setFragmentShadingRateKHR(const vk::Extent2D *pFragmentSize, const vk::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void preprocessGeneratedCommandsNV(const vk::GeneratedCommandsInfoNV &generatedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeTimestamp(vk::PipelineStageFlagBits pipelineStage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImageToBuffer2KHR(const vk::CopyImageToBufferInfo2 *pCopyImageToBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructuresIndirectKHR(uint32_t infoCount, const vk::AccelerationStructureBuildGeometryInfoKHR *pInfos, const vk::DeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyQueryPoolResults(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBufferToImage(vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::BufferImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCoverageModulationModeNV(vk::CoverageModulationModeNV coverageModulationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRendering(const vk::RenderingInfo &renderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setExtraPrimitiveOverestimationSizeEXT(float extraPrimitiveOverestimationSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilWriteMask(vk::StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type begin(const vk::CommandBufferBeginInfo &beginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void writeAccelerationStructuresPropertiesNV(uint32_t accelerationStructureCount, const vk::AccelerationStructureNV *pAccelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updatePipelineIndirectBufferNV(vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setPrimitiveRestartEnableEXT(vk::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers2(uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer *pBuffers, const vk::DeviceSize *pOffsets, const vk::DeviceSize *pSizes, const vk::DeviceSize *pStrides, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(const vk::PerformanceMarkerInfoINTEL *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMicromapEXT(const vk::CopyMicromapInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endConditionalRenderingEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindDescriptorBufferEmbeddedSamplers2EXT(const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT &bindDescriptorBufferEmbeddedSamplersInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::ImageBlit > const &regions, vk::Filter filter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindShadingRateImageNV(vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setPatchControlPointsEXT(uint32_t patchControlPoints, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const vk::Buffer *pCounterBuffers, const vk::DeviceSize *pCounterBufferOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(const vk::PerformanceStreamMarkerInfoINTEL *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyAccelerationStructureKHR(const vk::CopyAccelerationStructureInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindDescriptorSets2KHR(const vk::BindDescriptorSetsInfoKHR *pBindDescriptorSetsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndexedIndirectCountKHR(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setPrimitiveRestartEnable(vk::Bool32 primitiveRestartEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setLineStippleEnableEXT(vk::Bool32 stippledLineEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMemoryToMicromapEXT(const vk::CopyMemoryToMicromapInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setProvokingVertexModeEXT(vk::ProvokingVertexModeEXT provokingVertexMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImage2KHR(const vk::CopyImageInfo2 &copyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewport(uint32_t firstViewport, vk::ArrayProxy< const vk::Viewport > const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderPass2KHR(const vk::RenderPassBeginInfo *pRenderPassBegin, const vk::SubpassBeginInfo *pSubpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBias2EXT(const vk::DepthBiasInfoEXT &depthBiasInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setLineRasterizationModeEXT(vk::LineRasterizationModeEXT lineRasterizationMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBufferToImage(vk::Buffer srcBuffer, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::BufferImageCopy > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pipelineBarrier2(const vk::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endTransformFeedbackEXT(uint32_t firstCounterBuffer, vk::ArrayProxy< const vk::Buffer > const &counterBuffers, vk::ArrayProxy< const vk::DeviceSize > const &counterBufferOffsets VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void pushConstants(vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setScissor(uint32_t firstScissor, uint32_t scissorCount, const vk::Rect2D *pScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMultiEXT(uint32_t drawCount, const vk::MultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRenderingKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthClipEnableEXT(vk::Bool32 depthClipEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setFragmentShadingRateEnumNV(vk::FragmentShadingRateNV shadingRate, const vk::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetEvent2(vk::Event event, vk::PipelineStageFlags2 stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, vk::ArrayProxy< const vk::ImageCopy > const &regions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result begin(const vk::CommandBufferBeginInfo *pBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pipelineBarrier2KHR(const vk::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksIndirectCountNV(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImage2(const vk::CopyImageInfo2 &copyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage2(const vk::BlitImageInfo2 &blitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindDescriptorBufferEmbeddedSamplers2EXT(const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT *pBindDescriptorBufferEmbeddedSamplersInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDescriptorBufferOffsets2EXT(const vk::SetDescriptorBufferOffsetsInfoEXT *pSetDescriptorBufferOffsetsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchBase(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRepresentativeFragmentTestEnableNV(vk::Bool32 representativeFragmentTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthTestEnable(vk::Bool32 depthTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCoverageModulationTableNV(vk::ArrayProxy< const float > const &coverageModulationTable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushDescriptorSet2KHR(const vk::PushDescriptorSetInfoKHR &pushDescriptorSetInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportWithCount(uint32_t viewportCount, const vk::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void clearAttachments(uint32_t attachmentCount, const vk::ClearAttachment *pAttachments, uint32_t rectCount, const vk::ClearRect *pRects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void clearColorImage(vk::Image image, vk::ImageLayout imageLayout, const vk::ClearColorValue &color, vk::ArrayProxy< const vk::ImageSubresourceRange > const &ranges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMicromapEXT(const vk::CopyMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildMicromapsEXT(uint32_t infoCount, const vk::MicromapBuildInfoEXT *pInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void debugMarkerInsertEXT(const vk::DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportSwizzleNV(uint32_t firstViewport, vk::ArrayProxy< const vk::ViewportSwizzleNV > const &viewportSwizzles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImage2KHR(const vk::CopyImageInfo2 *pCopyImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindIndexBuffer(vk::Buffer buffer, vk::DeviceSize offset, vk::IndexType indexType, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers(uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer *pBuffers, const vk::DeviceSize *pOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CommandBuffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4274
void setViewportShadingRatePaletteNV(uint32_t firstViewport, vk::ArrayProxy< const vk::ShadingRatePaletteNV > const &shadingRatePalettes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
CommandBuffer & operator=(VkCommandBuffer commandBuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4278
void setRasterizerDiscardEnable(vk::Bool32 rasterizerDiscardEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void nextSubpass2(const vk::SubpassBeginInfo *pSubpassBeginInfo, const vk::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyAccelerationStructureKHR(const vk::CopyAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setSampleMaskEXT(vk::SampleCountFlagBits samples, const vk::SampleMask *pSampleMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindPipeline(vk::PipelineBindPoint pipelineBindPoint, vk::Pipeline pipeline, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRenderPass2(const vk::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportSwizzleNV(uint32_t firstViewport, uint32_t viewportCount, const vk::ViewportSwizzleNV *pViewportSwizzles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endVideoCodingKHR(const vk::VideoEndCodingInfoKHR &endCodingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDescriptorBufferOffsetsEXT(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const vk::DeviceSize *pOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeMicromapsPropertiesEXT(uint32_t micromapCount, const vk::MicromapEXT *pMicromaps, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCullModeEXT(vk::CullModeFlags cullMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageBlit *pRegions, vk::Filter filter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilCompareMask(vk::StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportWScalingNV(uint32_t firstViewport, uint32_t viewportCount, const vk::ViewportWScalingNV *pViewportWScalings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMultiIndexedEXT(vk::StridedArrayProxy< const vk::MultiDrawIndexedInfoEXT > const &indexInfo, uint32_t instanceCount, uint32_t firstInstance, Optional< const int32_t > vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorWriteMaskEXT(uint32_t firstAttachment, vk::ArrayProxy< const vk::ColorComponentFlags > const &colorWriteMasks, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4303
void copyBuffer(vk::Buffer srcBuffer, vk::Buffer dstBuffer, uint32_t regionCount, const vk::BufferCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportShadingRatePaletteNV(uint32_t firstViewport, uint32_t viewportCount, const vk::ShadingRatePaletteNV *pShadingRatePalettes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRenderPass(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchGraphAMDX(vk::DeviceAddress scratch, const vk::DispatchGraphCountInfoAMDX *pCountInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorBlendEnableEXT(uint32_t firstAttachment, uint32_t attachmentCount, const vk::Bool32 *pColorBlendEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceMarkerINTEL(const vk::PerformanceMarkerInfoINTEL &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void bindIndexBuffer2KHR(vk::Buffer buffer, vk::DeviceSize offset, vk::DeviceSize size, vk::IndexType indexType, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRenderPass2KHR(const vk::SubpassEndInfo &subpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushDescriptorSetWithTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, DataType const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBuffer2KHR(const vk::CopyBufferInfo2 *pCopyBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchGraphIndirectCountAMDX(vk::DeviceAddress scratch, vk::DeviceAddress countInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeTimestamp2KHR(vk::PipelineStageFlags2 stage, vk::QueryPool queryPool, uint32_t query, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void nextSubpass2KHR(const vk::SubpassBeginInfo *pSubpassBeginInfo, const vk::SubpassEndInfo *pSubpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setShadingRateImageEnableNV(vk::Bool32 shadingRateImageEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilTestEnableEXT(vk::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchGraphAMDX(vk::DeviceAddress scratch, const vk::DispatchGraphCountInfoAMDX &countInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBiasEnable(vk::Bool32 depthBiasEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeAccelerationStructuresPropertiesKHR(vk::ArrayProxy< const vk::AccelerationStructureKHR > const &accelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRendering(const vk::RenderingInfo *pRenderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRenderPass2(const vk::SubpassEndInfo &subpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDescriptorBufferOffsets2EXT(const vk::SetDescriptorBufferOffsetsInfoEXT &setDescriptorBufferOffsetsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void traceRaysIndirect2KHR(vk::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMultiIndexedEXT(uint32_t drawCount, const vk::MultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endQueryIndexedEXT(vk::QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resolveImage2(const vk::ResolveImageInfo2 &resolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewport(uint32_t firstViewport, uint32_t viewportCount, const vk::Viewport *pViewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushDescriptorSetKHR(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const vk::WriteDescriptorSet *pDescriptorWrites, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pushDescriptorSetWithTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, vk::PipelineLayout layout, uint32_t set, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endRendering(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resolveImage2KHR(const vk::ResolveImageInfo2 &resolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderPass(const vk::RenderPassBeginInfo &renderPassBegin, vk::SubpassContents contents, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCoverageModulationTableEnableNV(vk::Bool32 coverageModulationTableEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(CommandBuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4293
void setCoverageModulationTableNV(uint32_t coverageModulationTableCount, const float *pCoverageModulationTable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void executeGeneratedCommandsNV(vk::Bool32 isPreprocessed, const vk::GeneratedCommandsInfoNV *pGeneratedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilOp(vk::StencilFaceFlags faceMask, vk::StencilOp failOp, vk::StencilOp passOp, vk::StencilOp depthFailOp, vk::CompareOp compareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorBlendEnableEXT(uint32_t firstAttachment, vk::ArrayProxy< const vk::Bool32 > const &colorBlendEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, vk::ArrayProxy< const vk::Rect2D > const &discardRectangles, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT &labelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderPass2(const vk::RenderPassBeginInfo *pRenderPassBegin, const vk::SubpassBeginInfo *pSubpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCoverageToColorEnableNV(vk::Bool32 coverageToColorEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBufferToImage2(const vk::CopyBufferToImageInfo2 &copyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMemoryToMicromapEXT(const vk::CopyMemoryToMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resolveImage2KHR(const vk::ResolveImageInfo2 *pResolveImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setLineWidth(float lineWidth, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCoarseSampleOrderNV(vk::CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const vk::CoarseSampleOrderCustomNV *pCustomSampleOrders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilTestEnable(vk::Bool32 stencilTestEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageCopy *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setEvent2KHR(vk::Event event, const vk::DependencyInfo &dependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndirectCountAMD(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void decompressMemoryIndirectCountNV(vk::DeviceAddress indirectCommandsAddress, vk::DeviceAddress indirectCommandsCountAddress, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void executeGeneratedCommandsNV(vk::Bool32 isPreprocessed, const vk::GeneratedCommandsInfoNV &generatedCommandsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginRenderPass2KHR(const vk::RenderPassBeginInfo &renderPassBegin, const vk::SubpassBeginInfo &subpassBeginInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndirectByteCountEXT(uint32_t instanceCount, uint32_t firstInstance, vk::Buffer counterBuffer, vk::DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void cuLaunchKernelNVX(const vk::CuLaunchInfoNVX &launchInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void executeCommands(vk::ArrayProxy< const vk::CommandBuffer > const &commandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setSampleLocationsEXT(const vk::SampleLocationsInfoEXT *pSampleLocationsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const vk::AccelerationStructureKHR *pAccelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void debugMarkerBeginEXT(const vk::DebugMarkerMarkerInfoEXT &markerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6595
void cudaLaunchKernelNV(const vk::CudaLaunchInfoNV *pLaunchInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setFrontFace(vk::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void writeAccelerationStructuresPropertiesNV(vk::ArrayProxy< const vk::AccelerationStructureNV > const &accelerationStructures, vk::QueryType queryType, vk::QueryPool queryPool, uint32_t firstQuery, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorWriteEnableEXT(uint32_t attachmentCount, const vk::Bool32 *pColorWriteEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void blitImage2KHR(const vk::BlitImageInfo2 &blitImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindDescriptorBuffersEXT(uint32_t bufferCount, const vk::DescriptorBufferBindingInfoEXT *pBindingInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updateBuffer(vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::DeviceSize dataSize, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchBaseKHR(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetQueryPool(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void waitEvents2(vk::ArrayProxy< const vk::Event > const &events, vk::ArrayProxy< const vk::DependencyInfo > const &dependencyInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void setCheckpointNV(CheckpointMarkerType const &checkpointMarker, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyAccelerationStructureNV(vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::CopyAccelerationStructureModeKHR mode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginQueryIndexedEXT(vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, uint32_t index, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindShadersEXT(uint32_t stageCount, const vk::ShaderStageFlagBits *pStages, const vk::ShaderEXT *pShaders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setExclusiveScissorNV(uint32_t firstExclusiveScissor, vk::ArrayProxy< const vk::Rect2D > const &exclusiveScissors, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthWriteEnableEXT(vk::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void insertDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT &labelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void nextSubpass2(const vk::SubpassBeginInfo &subpassBeginInfo, const vk::SubpassEndInfo &subpassEndInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR CommandBuffer()=default
void clearAttachments(vk::ArrayProxy< const vk::ClearAttachment > const &attachments, vk::ArrayProxy< const vk::ClearRect > const &rects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMemoryToAccelerationStructureKHR(const vk::CopyMemoryToAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawMeshTasksEXT(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setEvent(vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void insertDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setVertexInputEXT(vk::ArrayProxy< const vk::VertexInputBindingDescription2EXT > const &vertexBindingDescriptions, vk::ArrayProxy< const vk::VertexInputAttributeDescription2EXT > const &vertexAttributeDescriptions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindShadersEXT(vk::ArrayProxy< const vk::ShaderStageFlagBits > const &stages, vk::ArrayProxy< const vk::ShaderEXT > const &shaders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void bindInvocationMaskHUAWEI(vk::ImageView imageView, vk::ImageLayout imageLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetEvent(vk::Event event, vk::PipelineStageFlags stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructureNV(const vk::AccelerationStructureInfoNV &info, vk::Buffer instanceData, vk::DeviceSize instanceOffset, vk::Bool32 update, vk::AccelerationStructureNV dst, vk::AccelerationStructureNV src, vk::Buffer scratch, vk::DeviceSize scratchOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthCompareOpEXT(vk::CompareOp depthCompareOp, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setViewportWithCount(vk::ArrayProxy< const vk::Viewport > const &viewports, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VkCommandBuffer CType
Definition: vulkan_handles.hpp:4264
void resolveImage(vk::Image srcImage, vk::ImageLayout srcImageLayout, vk::Image dstImage, vk::ImageLayout dstImageLayout, uint32_t regionCount, const vk::ImageResolve *pRegions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void initializeGraphScratchMemoryAMDX(vk::DeviceAddress scratch, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setEvent2(vk::Event event, const vk::DependencyInfo *pDependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(const vk::PerformanceOverrideInfoINTEL *pOverrideInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setSampleLocationsEnableEXT(vk::Bool32 sampleLocationsEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMemoryToAccelerationStructureKHR(const vk::CopyMemoryToAccelerationStructureInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyBufferToImage2KHR(const vk::CopyBufferToImageInfo2 &copyBufferToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setRasterizationSamplesEXT(vk::SampleCountFlagBits rasterizationSamples, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDepthWriteEnable(vk::Bool32 depthWriteEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pipelineBarrier(vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, vk::DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const vk::MemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier *pImageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setColorWriteEnableEXT(vk::ArrayProxy< const vk::Bool32 > const &colorWriteEnables, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void pipelineBarrier2(const vk::DependencyInfo &dependencyInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndexedIndirectCount(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindVertexBuffers2EXT(uint32_t firstBinding, uint32_t bindingCount, const vk::Buffer *pBuffers, const vk::DeviceSize *pOffsets, const vk::DeviceSize *pSizes, const vk::DeviceSize *pStrides, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setFragmentShadingRateKHR(const vk::Extent2D &fragmentSize, const vk::FragmentShadingRateCombinerOpKHR combinerOps[2], Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setStencilReference(vk::StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void bindDescriptorSets(vk::PipelineBindPoint pipelineBindPoint, vk::PipelineLayout layout, uint32_t firstSet, vk::ArrayProxy< const vk::DescriptorSet > const &descriptorSets, vk::ArrayProxy< const uint32_t > const &dynamicOffsets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setFrontFaceEXT(vk::FrontFace frontFace, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatchIndirect(vk::Buffer buffer, vk::DeviceSize offset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setDiscardRectangleModeEXT(vk::DiscardRectangleModeEXT discardRectangleMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void beginQuery(vk::QueryPool queryPool, uint32_t query, vk::QueryControlFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetEvent2KHR(vk::Event event, vk::PipelineStageFlags2 stageMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updateBuffer(vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::ArrayProxy< const DataType > const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setSampleMaskEXT(vk::SampleCountFlagBits samples, vk::ArrayProxy< const vk::SampleMask > const &sampleMask, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void traceRaysIndirectKHR(const vk::StridedDeviceAddressRegionKHR &raygenShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &missShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &hitShaderBindingTable, const vk::StridedDeviceAddressRegionKHR &callableShaderBindingTable, vk::DeviceAddress indirectDeviceAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMicromapToMemoryEXT(const vk::CopyMicromapToMemoryInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void drawIndirectCount(vk::Buffer buffer, vk::DeviceSize offset, vk::Buffer countBuffer, vk::DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyMicromapToMemoryEXT(const vk::CopyMicromapToMemoryInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildAccelerationStructuresKHR(uint32_t infoCount, const vk::AccelerationStructureBuildGeometryInfoKHR *pInfos, const vk::AccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setCoarseSampleOrderNV(vk::CoarseSampleOrderTypeNV sampleOrderType, vk::ArrayProxy< const vk::CoarseSampleOrderCustomNV > const &customSampleOrders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void clearColorImage(vk::Image image, vk::ImageLayout imageLayout, const vk::ClearColorValue *pColor, uint32_t rangeCount, const vk::ImageSubresourceRange *pRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void buildMicromapsEXT(vk::ArrayProxy< const vk::MicromapBuildInfoEXT > const &infos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void waitEvents(uint32_t eventCount, const vk::Event *pEvents, vk::PipelineStageFlags srcStageMask, vk::PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const vk::MemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const vk::BufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const vk::ImageMemoryBarrier *pImageMemoryBarriers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void copyAccelerationStructureToMemoryKHR(const vk::CopyAccelerationStructureToMemoryInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type reset(vk::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setSampleLocationsEXT(const vk::SampleLocationsInfoEXT &sampleLocationsInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7054
VkCommandPool NativeType
Definition: vulkan_handles.hpp:7057
VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool(VkCommandPool commandPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7068
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7113
VULKAN_HPP_CONSTEXPR CommandPool()=default
bool operator!=(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7092
CommandPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7078
VULKAN_HPP_CONSTEXPR CommandPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7066
VkCommandPool CType
Definition: vulkan_handles.hpp:7056
bool operator<(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7097
bool operator==(CommandPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7087
Definition: vulkan_handles.hpp:7228
VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7242
bool operator!=(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7266
bool operator<(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7271
VkCuFunctionNVX NativeType
Definition: vulkan_handles.hpp:7231
VkCuFunctionNVX CType
Definition: vulkan_handles.hpp:7230
CuFunctionNVX & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7252
bool operator==(CuFunctionNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7261
VULKAN_HPP_CONSTEXPR CuFunctionNVX()=default
VULKAN_HPP_CONSTEXPR CuFunctionNVX(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7240
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7287
Definition: vulkan_handles.hpp:7315
VULKAN_HPP_CONSTEXPR CuModuleNVX(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7327
VkCuModuleNVX CType
Definition: vulkan_handles.hpp:7317
VULKAN_HPP_CONSTEXPR CuModuleNVX()=default
VkCuModuleNVX NativeType
Definition: vulkan_handles.hpp:7318
CuModuleNVX & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7339
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7374
VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX(VkCuModuleNVX cuModuleNVX) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7329
bool operator==(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7348
bool operator!=(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7353
bool operator<(CuModuleNVX const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7358
Definition: vulkan_handles.hpp:7403
VULKAN_HPP_CONSTEXPR CudaFunctionNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7415
VULKAN_HPP_CONSTEXPR CudaFunctionNV()=default
bool operator==(CudaFunctionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7436
CudaFunctionNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7427
VkCudaFunctionNV CType
Definition: vulkan_handles.hpp:7405
VkCudaFunctionNV NativeType
Definition: vulkan_handles.hpp:7406
VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV(VkCudaFunctionNV cudaFunctionNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7417
bool operator<(CudaFunctionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7446
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7462
bool operator!=(CudaFunctionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7441
Definition: vulkan_handles.hpp:7492
VULKAN_HPP_CONSTEXPR CudaModuleNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7504
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7551
bool operator<(CudaModuleNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7535
VULKAN_HPP_CONSTEXPR CudaModuleNV()=default
bool operator!=(CudaModuleNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7530
VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV(VkCudaModuleNV cudaModuleNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7506
VkCudaModuleNV CType
Definition: vulkan_handles.hpp:7494
CudaModuleNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7516
VkCudaModuleNV NativeType
Definition: vulkan_handles.hpp:7495
bool operator==(CudaModuleNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7525
Definition: vulkan_handles.hpp:2442
VkDebugReportCallbackEXT CType
Definition: vulkan_handles.hpp:2444
bool operator==(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2478
bool operator<(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2488
DebugReportCallbackEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2469
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2504
VkDebugReportCallbackEXT NativeType
Definition: vulkan_handles.hpp:2445
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()=default
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2454
bool operator!=(DebugReportCallbackEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2483
VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2456
Definition: vulkan_handles.hpp:2532
bool operator<(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2578
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2544
DebugUtilsMessengerEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2559
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2594
bool operator!=(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2573
VkDebugUtilsMessengerEXT NativeType
Definition: vulkan_handles.hpp:2535
VkDebugUtilsMessengerEXT CType
Definition: vulkan_handles.hpp:2534
bool operator==(DebugUtilsMessengerEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2568
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()=default
VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2546
Definition: vulkan_handles.hpp:6791
bool operator==(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6827
VULKAN_HPP_CONSTEXPR DeferredOperationKHR()=default
bool operator<(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6837
VkDeferredOperationKHR CType
Definition: vulkan_handles.hpp:6793
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6853
DeferredOperationKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6818
VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6805
VkDeferredOperationKHR NativeType
Definition: vulkan_handles.hpp:6794
bool operator!=(DeferredOperationKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6832
VULKAN_HPP_CONSTEXPR DeferredOperationKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6803
Definition: vulkan_handles.hpp:7580
DescriptorPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7604
VULKAN_HPP_CONSTEXPR DescriptorPool()=default
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool(VkDescriptorPool descriptorPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7594
VkDescriptorPool NativeType
Definition: vulkan_handles.hpp:7583
bool operator<(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7623
VULKAN_HPP_CONSTEXPR DescriptorPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7592
bool operator==(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7613
VkDescriptorPool CType
Definition: vulkan_handles.hpp:7582
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7639
bool operator!=(DescriptorPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7618
Definition: vulkan_handles.hpp:7667
DescriptorSetLayout & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7694
bool operator==(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7703
VULKAN_HPP_CONSTEXPR DescriptorSetLayout()=default
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7681
VULKAN_HPP_CONSTEXPR DescriptorSetLayout(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7679
bool operator!=(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7708
VkDescriptorSetLayout CType
Definition: vulkan_handles.hpp:7669
VkDescriptorSetLayout NativeType
Definition: vulkan_handles.hpp:7670
bool operator<(DescriptorSetLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7713
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7729
Definition: vulkan_handles.hpp:3309
VkDescriptorSet CType
Definition: vulkan_handles.hpp:3311
bool operator==(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3342
bool operator<(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3352
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet(VkDescriptorSet descriptorSet) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3323
VULKAN_HPP_CONSTEXPR DescriptorSet(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3321
VkDescriptorSet NativeType
Definition: vulkan_handles.hpp:3312
VULKAN_HPP_CONSTEXPR DescriptorSet()=default
bool operator!=(DescriptorSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3347
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3368
DescriptorSet & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3333
Definition: vulkan_handles.hpp:3912
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3974
bool operator==(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3948
VkDescriptorUpdateTemplate NativeType
Definition: vulkan_handles.hpp:3915
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3926
bool operator!=(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3953
DescriptorUpdateTemplate & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3939
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3924
VkDescriptorUpdateTemplate CType
Definition: vulkan_handles.hpp:3914
bool operator<(DescriptorUpdateTemplate const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3958
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()=default
Definition: vulkan_handles.hpp:6623
VkDeviceMemory NativeType
Definition: vulkan_handles.hpp:6626
VkDeviceMemory CType
Definition: vulkan_handles.hpp:6625
bool operator<(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6666
VULKAN_HPP_CONSTEXPR DeviceMemory()=default
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6682
VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory(VkDeviceMemory deviceMemory) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6637
bool operator!=(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6661
DeviceMemory & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6647
bool operator==(DeviceMemory const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6656
VULKAN_HPP_CONSTEXPR DeviceMemory(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6635
Definition: vulkan_handles.hpp:8782
VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT(const vk::ReleaseSwapchainImagesInfoEXT *pReleaseInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createFence(const vk::FenceCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< vk::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector< uint8_t, Uint8_tAllocator > > >::type getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR &videoSessionParametersInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setHdrMetadataEXT(vk::ArrayProxy< const vk::SwapchainKHR > const &swapchains, vk::ArrayProxy< const vk::HdrMetadataEXT > const &metadata, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
void destroyCuModuleNVX(vk::CuModuleNVX module, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::IndirectCommandsLayoutNV indirectCommandsLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPrivateDataSlotEXT(vk::PrivateDataSlot privateDataSlot, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Image, Dispatch > >::type createImageUnique(const vk::ImageCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyPipelineLayout(vk::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeviceAddress getPipelineIndirectAddressNV(const vk::PipelineIndirectDeviceAddressInfoNV *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyAccelerationStructureNV(vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE(const vk::DescriptorSetBindingReferenceVALVE &bindingReference, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type signalSemaphore(const vk::SemaphoreSignalInfo &signalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getImageMemoryRequirements2(const vk::ImageMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::ShaderModule, Dispatch > >::type createShaderModuleUnique(const vk::ShaderModuleCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyFramebuffer(vk::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type debugMarkerSetObjectNameEXT(const vk::DebugMarkerObjectNameInfoEXT &nameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyCommandPool(vk::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::ShaderEXT, Dispatch >, ShaderEXTAllocator > >::type createShadersEXTUnique(vk::ArrayProxy< const vk::ShaderCreateInfoEXT > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, ShaderEXTAllocator &shaderEXTAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
uint32_t getDeferredOperationMaxConcurrencyKHR(vk::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirements(const vk::DeviceBufferMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::CudaFunctionNV >::type createCudaFunctionNV(const vk::CudaFunctionCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::pair< vk::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector< uint8_t, Uint8_tAllocator > > >::type getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR &videoSessionParametersInfo, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createGraphicsPipelinesUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::GraphicsPipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::Event >::type createEvent(const vk::EventCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::pair< uint64_t, uint64_t > >::type getCalibratedTimestampEXT(const vk::CalibratedTimestampInfoKHR &timestampInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::pair< uint64_t, uint64_t > >::type getCalibratedTimestampKHR(const vk::CalibratedTimestampInfoKHR &timestampInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeviceAddress getAccelerationStructureAddressKHR(const vk::AccelerationStructureDeviceAddressInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyAccelerationStructureNV(vk::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createValidationCacheEXT(const vk::ValidationCacheCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::ValidationCacheEXT *pValidationCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT(const vk::BufferCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createRayTracingPipelineKHR(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, const vk::RayTracingPipelineCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getDescriptorSetLayoutSizeEXT(vk::DescriptorSetLayout layout, vk::DeviceSize *pLayoutSizeInBytes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements2KHR(const vk::ImageSparseMemoryRequirementsInfo2 &info, SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::pair< vk::DeviceFaultCountsEXT, vk::DeviceFaultInfoEXT > > getFaultInfoEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createCuFunctionNVX(const vk::CuFunctionCreateInfoNVX *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::CuFunctionNVX *pFunction, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type writeAccelerationStructuresPropertiesKHR(vk::ArrayProxy< const vk::AccelerationStructureKHR > const &accelerationStructures, vk::QueryType queryType, size_t dataSize, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyImage(vk::Image image VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::ExecutionGraphPipelineScratchSizeAMDX >::type getExecutionGraphPipelineScratchSizeAMDX(vk::Pipeline executionGraph, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result importFenceFdKHR(const vk::ImportFenceFdInfoKHR *pImportFenceFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(uint32_t timestampCount, const vk::CalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::MicromapEXT, Dispatch > >::type createMicromapEXTUnique(const vk::MicromapCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
uint64_t getBufferOpaqueCaptureAddressKHR(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageMemoryRequirements(vk::Image image, vk::MemoryRequirements *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DescriptorSet, DescriptorSetAllocator > >::type allocateDescriptorSets(const vk::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getAccelerationStructureMemoryRequirementsNV(const vk::AccelerationStructureMemoryRequirementsInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DeviceMemory, Dispatch > >::type allocateMemoryUnique(const vk::MemoryAllocateInfo &allocateInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createExecutionGraphPipelinesAMDX(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ExecutionGraphPipelineCreateInfoAMDX > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD uint64_t getPrivateData(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyOpticalFlowSessionNV(vk::OpticalFlowSessionNV session, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createShaderModule(const vk::ShaderModuleCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::ShaderModule *pShaderModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setMemoryPriorityEXT(vk::DeviceMemory memory, float priority, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Buffer buffer, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::Sampler >::type createSampler(const vk::SamplerCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Framebuffer, Dispatch > >::type createFramebufferUnique(const vk::FramebufferCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getBufferMemoryRequirements2KHR(const vk::BufferMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPrivateDataSlotEXT(vk::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::PrivateDataSlot >::type createPrivateDataSlot(const vk::PrivateDataSlotCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createPipelineLayout(const vk::PipelineLayoutCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::PipelineLayout *pPipelineLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< uint64_t, Uint64_tAllocator >, uint64_t > >::type getCalibratedTimestampsKHR(vk::ArrayProxy< const vk::CalibratedTimestampInfoKHR > const &timestampInfos, Uint64_tAllocator &uint64_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getImageViewAddressNVX(vk::ImageView imageView, vk::ImageViewAddressPropertiesNVX *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getMemoryCommitment(vk::DeviceMemory memory, vk::DeviceSize *pCommittedMemoryInBytes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result allocateMemory(const vk::MemoryAllocateInfo *pAllocateInfo, const vk::AllocationCallbacks *pAllocator, vk::DeviceMemory *pMemory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< void * >::type mapMemory(vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void resetQueryPoolEXT(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::RefreshCycleDurationGOOGLE >::type getRefreshCycleDurationGOOGLE(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::Result waitForPresentKHR(vk::SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::DescriptorSetLayout >::type createDescriptorSetLayout(const vk::DescriptorSetLayoutCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR(uint32_t timestampCount, const vk::CalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyEvent(vk::Event event VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getMemoryFdKHR(const vk::MemoryGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Event event, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< uint32_t > acquireNextImage2KHR(const vk::AcquireNextImageInfoKHR &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::DescriptorUpdateTemplate >::type createDescriptorUpdateTemplateKHR(const vk::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setLocalDimmingAMD(vk::SwapchainKHR swapChain, vk::Bool32 localDimmingEnable, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MicromapBuildSizesInfoEXT getMicromapBuildSizesEXT(vk::AccelerationStructureBuildTypeKHR buildType, const vk::MicromapBuildInfoEXT &buildInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type importSemaphoreFdKHR(const vk::ImportSemaphoreFdInfoKHR &importSemaphoreFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void unmapMemory2KHR(const vk::MemoryUnmapInfoKHR &memoryUnmapInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(const vk::DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SwapchainKHR, SwapchainKHRAllocator > >::type createSharedSwapchainsKHR(vk::ArrayProxy< const vk::SwapchainCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::CudaModuleNV >::type createCudaModuleNV(const vk::CudaModuleCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyDescriptorPool(vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT(const vk::PrivateDataSlotCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::PrivateDataSlot *pPrivateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getShaderBinaryDataEXT(vk::ShaderEXT shader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type debugMarkerSetObjectTagEXT(const vk::DebugMarkerObjectTagInfoEXT &tagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result bindImageMemory2(uint32_t bindInfoCount, const vk::BindImageMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type displayPowerControlEXT(vk::DisplayKHR display, const vk::DisplayPowerInfoEXT &displayPowerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionKHRUnique(const vk::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX(vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::ExecutionGraphPipelineCreateInfoAMDX *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createGraphicsPipelineUnique(vk::PipelineCache pipelineCache, const vk::GraphicsPipelineCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT(const vk::ShaderModuleCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::DeferredOperationKHR >::type createDeferredOperationKHR(Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::AccelerationStructureNV accelerationStructure, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result acquireNextImage2KHR(const vk::AcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::BufferView, Dispatch > >::type createBufferViewUnique(const vk::BufferViewCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< uint64_t, Uint64_tAllocator >, uint64_t > >::type getCalibratedTimestampsEXT(vk::ArrayProxy< const vk::CalibratedTimestampInfoKHR > const &timestampInfos, Uint64_tAllocator &uint64_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::AccelerationStructureNV >::type createAccelerationStructureNV(const vk::AccelerationStructureCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createComputePipelinesUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ComputePipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroySemaphore(vk::Semaphore semaphore, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setDebugUtilsObjectTagEXT(const vk::DebugUtilsObjectTagInfoEXT &tagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE(vk::DescriptorSet descriptorSet, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::GetLatencyMarkerInfoNV getLatencyTimingsNV(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyEvent(vk::Event event, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::MemoryFdPropertiesKHR >::type getMemoryFdPropertiesKHR(vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyCudaModuleNV(vk::CudaModuleNV module, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(vk::Semaphore semaphore, uint64_t *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type copyImageToImageEXT(const vk::CopyImageToImageInfoEXT &copyImageToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createExecutionGraphPipelineAMDX(vk::PipelineCache pipelineCache, const vk::ExecutionGraphPipelineCreateInfoAMDX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyDeferredOperationKHR(vk::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyAccelerationStructureKHR(vk::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(vk::DeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getShaderModuleCreateInfoIdentifierEXT(const vk::ShaderModuleCreateInfo *pCreateInfo, vk::ShaderModuleIdentifierEXT *pIdentifier, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result copyMicromapToMemoryEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMicromapToMemoryInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(const vk::InitializePerformanceApiInfoINTEL *pInitializeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getAccelerationStructureMemoryRequirementsNV(const vk::AccelerationStructureMemoryRequirementsInfoNV *pInfo, vk::MemoryRequirements2KHR *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Image image, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyValidationCacheEXT(vk::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageSparseMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::CuFunctionNVX, Dispatch > >::type createCuFunctionNVXUnique(const vk::CuFunctionCreateInfoNVX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createExecutionGraphPipelinesAMDX(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ExecutionGraphPipelineCreateInfoAMDX > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getRenderAreaGranularity(vk::RenderPass renderPass, vk::Extent2D *pGranularity, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getMicromapBuildSizesEXT(vk::AccelerationStructureBuildTypeKHR buildType, const vk::MicromapBuildInfoEXT *pBuildInfo, vk::MicromapBuildSizesInfoEXT *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getDescriptorSetLayoutHostMappingInfoVALVE(const vk::DescriptorSetBindingReferenceVALVE *pBindingReference, vk::DescriptorSetLayoutHostMappingInfoVALVE *pHostMapping, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::ShaderEXT, Dispatch > >::type createShaderEXTUnique(const vk::ShaderCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::BufferView bufferView, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Fence, Dispatch > >::type registerEventEXTUnique(const vk::DeviceEventInfoEXT &deviceEventInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result buildMicromapsEXT(vk::DeferredOperationKHR deferredOperation, uint32_t infoCount, const vk::MicromapBuildInfoEXT *pInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator > >::type getPipelineExecutableInternalRepresentationsKHR(const vk::PipelineExecutableInfoKHR &executableInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result bindBufferMemory2(uint32_t bindInfoCount, const vk::BindBufferMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SwapchainKHR, SwapchainKHRAllocator > >::type createSharedSwapchainsKHR(vk::ArrayProxy< const vk::SwapchainCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, SwapchainKHRAllocator &swapchainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getShaderModuleIdentifierEXT(vk::ShaderModule shaderModule, vk::ShaderModuleIdentifierEXT *pIdentifier, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::PipelineCache >::type createPipelineCache(const vk::PipelineCacheCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void unmapMemory(vk::DeviceMemory memory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::OpticalFlowSessionNV, Dispatch > >::type createOpticalFlowSessionNVUnique(const vk::OpticalFlowSessionCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::AccelerationStructureNV accelerationStructure, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getDescriptorSetLayoutSupport(const vk::DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updateDescriptorSetWithTemplate(vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13892
void getPipelineIndirectMemoryRequirementsNV(const vk::ComputePipelineCreateInfo *pCreateInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result latencySleepNV(vk::SwapchainKHR swapchain, const vk::LatencySleepInfoNV *pSleepInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void trimCommandPool(vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySamplerYcbcrConversionKHR(vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getAccelerationStructureHandleNV(vk::AccelerationStructureNV accelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::CuFunctionNVX function, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getShaderInfoAMD(vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyShaderModule(vk::ShaderModule shaderModule, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(const vk::SamplerYcbcrConversionCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageSubresourceLayout2KHR(vk::Image image, const vk::ImageSubresource2KHR *pSubresource, vk::SubresourceLayout2KHR *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type mergePipelineCaches(vk::PipelineCache dstCache, vk::ArrayProxy< const vk::PipelineCache > const &srcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result copyImageToImageEXT(const vk::CopyImageToImageInfoEXT *pCopyImageToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
vk::DeviceAddress getAccelerationStructureAddressKHR(const vk::AccelerationStructureDeviceAddressInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type transitionImageLayoutEXT(vk::ArrayProxy< const vk::HostImageLayoutTransitionInfoEXT > const &transitions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::RayTracingPipelineCreateInfoNV *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirementsKHR(const vk::DeviceBufferMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Device(VkDevice device) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8796
VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(vk::SurfaceKHR surface, vk::DeviceGroupPresentModeFlagsKHR *pModes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void freeCommandBuffers(vk::CommandPool commandPool, uint32_t commandBufferCount, const vk::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::RenderPass renderPass, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getValidationCacheDataEXT(vk::ValidationCacheEXT validationCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyImageView(vk::ImageView imageView, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT(const vk::CopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type resetCommandPool(vk::CommandPool commandPool, vk::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::DeviceSize getMemoryCommitment(vk::DeviceMemory memory, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type writeMicromapsPropertiesEXT(vk::ArrayProxy< const vk::MicromapEXT > const &micromaps, vk::QueryType queryType, size_t dataSize, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createBufferView(const vk::BufferViewCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::BufferView *pView, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createCuModuleNVX(const vk::CuModuleCreateInfoNVX *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::CuModuleNVX *pModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getBufferMemoryRequirements2(const vk::BufferMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(const vk::DebugUtilsObjectNameInfoEXT *pNameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMemoryToMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createRayTracingPipelineNVUnique(vk::PipelineCache pipelineCache, const vk::RayTracingPipelineCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getQueryPoolResults(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, vk::DeviceSize stride, vk::QueryResultFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VkDevice NativeType
Definition: vulkan_handles.hpp:8785
void destroyVideoSessionParametersKHR(vk::VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createComputePipelinesUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ComputePipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< vk::Extent2D > getSubpassShadingMaxWorkgroupSizeHUAWEI(vk::RenderPass renderpass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::PipelineLayout >::type createPipelineLayout(const vk::PipelineLayoutCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyMicromapEXT(vk::MicromapEXT micromap VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updateDescriptorSetWithTemplateKHR(vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setEvent(vk::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyPipelineCache(vk::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyValidationCacheEXT(vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getShaderInfoAMD(vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::ValidationCacheEXT validationCache, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::DeviceGroupPresentModeFlagsKHR >::type getGroupSurfacePresentModesKHR(vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const vk::AccelerationStructureKHR *pAccelerationStructures, vk::QueryType queryType, size_t dataSize, void *pData, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type initializePerformanceApiINTEL(const vk::InitializePerformanceApiInfoINTEL &initializeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Fence, Dispatch > >::type createFenceUnique(const vk::FenceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::BufferView >::type createBufferView(const vk::BufferViewCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
DeviceAddress getBufferAddressEXT(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result copyAccelerationStructureToMemoryKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyAccelerationStructureToMemoryInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::VideoSessionParametersKHR >::type createVideoSessionParametersKHR(const vk::VideoSessionParametersCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator > >::type getPipelineExecutableStatisticsKHR(const vk::PipelineExecutableInfoKHR &executableInfo, PipelineExecutableStatisticKHRAllocator &pipelineExecutableStatisticKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(const vk::PipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, vk::PipelineExecutableStatisticKHR *pStatistics, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Buffer buffer, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDescriptorUpdateTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(const vk::AccelerationStructureCreateInfoNV *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::AccelerationStructureNV *pAccelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result waitSemaphores(const vk::SemaphoreWaitInfo &waitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindOpticalFlowSessionImageNV(vk::OpticalFlowSessionNV session, vk::OpticalFlowSessionBindingPointNV bindingPoint, vk::ImageView view, vk::ImageLayout layout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::ImageView imageView, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createGraphicsPipeline(vk::PipelineCache pipelineCache, const vk::GraphicsPipelineCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::ShaderEXT shader, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updateDescriptorSets(vk::ArrayProxy< const vk::WriteDescriptorSet > const &descriptorWrites, vk::ArrayProxy< const vk::CopyDescriptorSet > const &descriptorCopies, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateKHRUnique(const vk::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
DeviceAddress getBufferAddressKHR(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageViewOpaqueCaptureDescriptorDataEXT(const vk::ImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< int >::type getSemaphoreFdKHR(const vk::SemaphoreGetFdInfoKHR &getFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void freeMemory(vk::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::DescriptorSet, Dispatch >, DescriptorSetAllocator > >::type allocateDescriptorSetsUnique(const vk::DescriptorSetAllocateInfo &allocateInfo, DescriptorSetAllocator &descriptorSetAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::DescriptorUpdateTemplate >::type createDescriptorUpdateTemplate(const vk::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::DescriptorPool >::type createDescriptorPool(const vk::DescriptorPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyCommandPool(vk::CommandPool commandPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updateDescriptorSets(uint32_t descriptorWriteCount, const vk::WriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const vk::CopyDescriptorSet *pDescriptorCopies, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineScratchSizeAMDX(vk::Pipeline executionGraph, vk::ExecutionGraphPipelineScratchSizeAMDX *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Sampler, Dispatch > >::type createSamplerUnique(const vk::SamplerCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::CuModuleNVX module, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getImageMemoryRequirements(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result copyMemoryToMicromapEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMemoryToMicromapInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getSamplerOpaqueCaptureDescriptorDataEXT(const vk::SamplerCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type getAccelerationStructureHandleNV(vk::AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type acquireProfilingLockKHR(const vk::AcquireProfilingLockInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createPrivateDataSlot(const vk::PrivateDataSlotCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::PrivateDataSlot *pPrivateDataSlot, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getMicromapCompatibilityEXT(const vk::MicromapVersionInfoEXT *pVersionInfo, vk::AccelerationStructureCompatibilityKHR *pCompatibility, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::Framebuffer >::type createFramebuffer(const vk::FramebufferCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::CuModuleNVX, Dispatch > >::type createCuModuleNVXUnique(const vk::CuModuleCreateInfoNVX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT(const vk::DescriptorGetInfoEXT &descriptorInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyShaderEXT(vk::ShaderEXT shader, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createRayTracingPipelineKHRUnique(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, const vk::RayTracingPipelineCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageSubresourceLayout2EXT(vk::Image image, const vk::ImageSubresource2KHR &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type writeAccelerationStructuresPropertyKHR(vk::ArrayProxy< const vk::AccelerationStructureKHR > const &accelerationStructures, vk::QueryType queryType, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type invalidateMappedMemoryRanges(vk::ArrayProxy< const vk::MappedMemoryRange > const &memoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::Fence >::type registerDisplayEventEXT(vk::DisplayKHR display, const vk::DisplayEventInfoEXT &displayEventInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< uint32_t > acquireNextImageKHR(vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result registerDisplayEventEXT(vk::DisplayKHR display, const vk::DisplayEventInfoEXT *pDisplayEventInfo, const vk::AllocationCallbacks *pAllocator, vk::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getQueue2(const vk::DeviceQueueInfo2 *pQueueInfo, vk::Queue *pQueue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setLatencyMarkerNV(vk::SwapchainKHR swapchain, const vk::SetLatencyMarkerInfoNV *pLatencyMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result mapMemory(vk::DeviceMemory memory, vk::DeviceSize offset, vk::DeviceSize size, vk::MemoryMapFlags flags, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyCudaModuleNV(vk::CudaModuleNV module, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type setLatencySleepModeNV(vk::SwapchainKHR swapchain, const vk::LatencySleepModeInfoNV &sleepModeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirements2KHR(const vk::ImageMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyCuFunctionNVX(vk::CuFunctionNVX function, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createComputePipelines(vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::ComputePipelineCreateInfo *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getImageMemoryRequirements2KHR(const vk::ImageMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Device & operator=(VkDevice device) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8798
void getImageSparseMemoryRequirements(vk::Image image, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyVideoSessionKHR(vk::VideoSessionKHR videoSession, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::ValidationCacheEXT validationCache, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PrivateDataSlot, Dispatch > >::type createPrivateDataSlotUnique(const vk::PrivateDataSlotCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(const vk::DebugMarkerObjectNameInfoEXT *pNameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::SwapchainKHR, Dispatch >, SwapchainKHRAllocator > >::type createSharedSwapchainsKHRUnique(vk::ArrayProxy< const vk::SwapchainCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, SwapchainKHRAllocator &swapchainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingShaderGroupHandleNV(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getCudaModuleCacheNV(vk::CudaModuleNV module, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type getRayTracingShaderGroupHandlesNV(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::RenderPass, Dispatch > >::type createRenderPassUnique(const vk::RenderPassCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Event, Dispatch > >::type createEventUnique(const vk::EventCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::Result buildAccelerationStructuresKHR(vk::DeferredOperationKHR deferredOperation, vk::ArrayProxy< const vk::AccelerationStructureBuildGeometryInfoKHR > const &infos, vk::ArrayProxy< const vk::AccelerationStructureBuildRangeInfoKHR *const > const &pBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::Result copyMicromapEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMicromapInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroySamplerYcbcrConversionKHR(vk::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPipelineCache(vk::PipelineCache pipelineCache, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(vk::SwapchainKHR swapchain, vk::RefreshCycleDurationGOOGLE *pDisplayTimingProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createImageView(const vk::ImageViewCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::ImageView *pView, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< uint64_t >::type getSemaphoreCounterValue(vk::Semaphore semaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(const vk::IndirectCommandsLayoutCreateInfoNV *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::IndirectCommandsLayoutNV *pIndirectCommandsLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::ShaderModule shaderModule, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getAccelerationStructureCompatibilityKHR(const vk::AccelerationStructureVersionInfoKHR *pVersionInfo, vk::AccelerationStructureCompatibilityKHR *pCompatibility, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Pipeline pipeline, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(uint32_t memoryRangeCount, const vk::MappedMemoryRange *pMemoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(const vk::AccelerationStructureMemoryRequirementsInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue(vk::Semaphore semaphore, uint64_t *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void trimCommandPoolKHR(vk::CommandPool commandPool, vk::CommandPoolTrimFlags flags, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type flushMappedMemoryRanges(vk::ArrayProxy< const vk::MappedMemoryRange > const &memoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result registerEventEXT(const vk::DeviceEventInfoEXT *pDeviceEventInfo, const vk::AllocationCallbacks *pAllocator, vk::Fence *pFence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::MicromapEXT micromap, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyVideoSessionParametersKHR(vk::VideoSessionParametersKHR videoSessionParameters, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator > >::type getPastPresentationTimingGOOGLE(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::SwapchainKHR swapchain, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::SamplerYcbcrConversion >::type createSamplerYcbcrConversion(const vk::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMicromapToMemoryInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getPipelineCacheData(vk::PipelineCache pipelineCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindBufferMemory(vk::Buffer buffer, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Semaphore, Dispatch > >::type createSemaphoreUnique(const vk::SemaphoreCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::Queue getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8823
VULKAN_HPP_NODISCARD Result createRenderPass2KHR(const vk::RenderPassCreateInfo2 *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindAccelerationStructureMemoryNV(vk::ArrayProxy< const vk::BindAccelerationStructureMemoryInfoNV > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyCuModuleNVX(vk::CuModuleNVX module, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Semaphore semaphore, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< uint32_t >::type getExecutionGraphPipelineNodeIndexAMDX(vk::Pipeline executionGraph, const vk::PipelineShaderStageNodeCreateInfoAMDX &nodeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result waitForFences(uint32_t fenceCount, const vk::Fence *pFences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createGraphicsPipelines(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::GraphicsPipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(vk::DeferredOperationKHR deferredOperation, uint32_t infoCount, const vk::AccelerationStructureBuildGeometryInfoKHR *pInfos, const vk::AccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result copyAccelerationStructureKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyAccelerationStructureInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void setLatencyMarkerNV(vk::SwapchainKHR swapchain, const vk::SetLatencyMarkerInfoNV &latencyMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getBufferMemoryRequirements2(const vk::BufferMemoryRequirementsInfo2 *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getImageViewOpaqueCaptureDescriptorDataEXT(const vk::ImageViewCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyOpticalFlowSessionNV(vk::OpticalFlowSessionNV session, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPrivateDataSlot(vk::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::PipelineLayout pipelineLayout, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void setHdrMetadataEXT(uint32_t swapchainCount, const vk::SwapchainKHR *pSwapchains, const vk::HdrMetadataEXT *pMetadata, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result displayPowerControlEXT(vk::DisplayKHR display, const vk::DisplayPowerInfoEXT *pDisplayPowerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::SwapchainKHR >::type createSharedSwapchainKHR(const vk::SwapchainCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroySampler(vk::Sampler sampler, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(vk::PerformanceParameterTypeINTEL parameter, vk::PerformanceValueINTEL *pValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::RenderPass >::type createRenderPass2KHR(const vk::RenderPassCreateInfo2 &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::ValidationCacheEXT >::type createValidationCacheEXT(const vk::ValidationCacheCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::SwapchainKHR >::type createSwapchainKHR(const vk::SwapchainCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(vk::AccelerationStructureNV accelerationStructure, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::CudaFunctionNV function, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements &info, SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getGeneratedCommandsMemoryRequirementsNV(const vk::GeneratedCommandsMemoryRequirementsInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::AccelerationStructureNV, Dispatch > >::type createAccelerationStructureNVUnique(const vk::AccelerationStructureCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator > >::type getPastPresentationTimingGOOGLE(vk::SwapchainKHR swapchain, PastPresentationTimingGOOGLEAllocator &pastPresentationTimingGOOGLEAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR(const vk::ImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetQueryPool(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< DataType > getQueryPoolResult(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, vk::DeviceSize stride, vk::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(const vk::DebugUtilsObjectTagInfoEXT *pTagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::VideoSessionKHR videoSession, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::PipelineCache pipelineCache, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Device(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8794
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::CommandPool, Dispatch > >::type createCommandPoolUnique(const vk::CommandPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindImageMemory(vk::Image image, vk::DeviceMemory memory, vk::DeviceSize memoryOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyPrivateDataSlot(vk::PrivateDataSlot privateDataSlot, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getFenceFdKHR(const vk::FenceGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator > >::type getVideoSessionMemoryRequirementsKHR(vk::VideoSessionKHR videoSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type release(vk::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements(const vk::DeviceImageMemoryRequirements &info, SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::Event event, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Extent2D getRenderAreaGranularity(vk::RenderPass renderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CommandBuffer, CommandBufferAllocator > >::type allocateCommandBuffers(const vk::CommandBufferAllocateInfo &allocateInfo, CommandBufferAllocator &commandBufferAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroySamplerYcbcrConversion(vk::SamplerYcbcrConversion ycbcrConversion, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageDrmFormatModifierPropertiesEXT >::type getImageDrmFormatModifierPropertiesEXT(vk::Image image, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PipelineLayout, Dispatch > >::type createPipelineLayoutUnique(const vk::PipelineLayoutCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT(uint32_t micromapCount, const vk::MicromapEXT *pMicromaps, vk::QueryType queryType, size_t dataSize, void *pData, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(const vk::AllocationCallbacks *pAllocator, vk::DeferredOperationKHR *pDeferredOperation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result signalSemaphore(const vk::SemaphoreSignalInfo *pSignalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getBufferOpaqueCaptureDescriptorDataEXT(const vk::BufferCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result mapMemory2KHR(const vk::MemoryMapInfoKHR *pMemoryMapInfo, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindBufferMemory2KHR(vk::ArrayProxy< const vk::BindBufferMemoryInfo > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyShaderModule(vk::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::QueryPool queryPool, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyImageView(vk::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::VideoSessionKHR, Dispatch > >::type createVideoSessionKHRUnique(const vk::VideoSessionCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createRayTracingPipelinesKHR(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getImageSparseMemoryRequirements2(const vk::ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::VideoSessionParametersKHR videoSessionParameters, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesNVUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::CuModuleNVX module, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements2(const vk::ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::VideoSessionMemoryRequirementsKHR, VideoSessionMemoryRequirementsKHRAllocator > >::type getVideoSessionMemoryRequirementsKHR(vk::VideoSessionKHR videoSession, VideoSessionMemoryRequirementsKHRAllocator &videoSessionMemoryRequirementsKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(const vk::AccelerationStructureCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::AccelerationStructureKHR *pAccelerationStructure, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::Fence >::type createFence(const vk::FenceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getAccelerationStructureBuildSizesKHR(vk::AccelerationStructureBuildTypeKHR buildType, const vk::AccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, vk::AccelerationStructureBuildSizesInfoKHR *pSizeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(const vk::PerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, vk::PerformanceConfigurationINTEL *pConfiguration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result getDeferredOperationResultKHR(vk::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPipelineLayout(vk::PipelineLayout pipelineLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getDescriptorSetLayoutSupportKHR(const vk::DescriptorSetLayoutCreateInfo *pCreateInfo, vk::DescriptorSetLayoutSupport *pSupport, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const vk::AccelerationStructureCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getShaderBinaryDataEXT(vk::ShaderEXT shader, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR(const vk::SemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void releaseProfilingLockKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindImageMemory2(vk::ArrayProxy< const vk::BindImageMemoryInfo > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyBufferView(vk::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8813
void destroy(vk::DescriptorPool descriptorPool, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Framebuffer framebuffer, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV(const vk::ComputePipelineCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::SubresourceLayout2KHR getImageSubresourceLayoutKHR(const vk::DeviceImageSubresourceInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(vk::AccelerationStructureBuildTypeKHR buildType, const vk::AccelerationStructureBuildGeometryInfoKHR &buildInfo, vk::ArrayProxy< const uint32_t > const &maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::RenderPass, Dispatch > >::type createRenderPass2Unique(const vk::RenderPassCreateInfo2 &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const vk::AccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result allocateDescriptorSets(const vk::DescriptorSetAllocateInfo *pAllocateInfo, vk::DescriptorSet *pDescriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::SwapchainKHR swapchain, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getShaderInfoAMD(vk::Pipeline pipeline, vk::ShaderStageFlagBits shaderStage, vk::ShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getBufferMemoryRequirements2KHR(const vk::BufferMemoryRequirementsInfo2 *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createPipelineCache(const vk::PipelineCacheCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::PipelineCache *pPipelineCache, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::BaseOutStructure >::type getPipelinePropertiesEXT(const vk::PipelineInfoEXT &pipelineInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyCudaFunctionNV(vk::CudaFunctionNV function, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void updateDescriptorSetWithTemplateKHR(vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR(uint32_t bindInfoCount, const vk::BindBufferMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyCuFunctionNVX(vk::CuFunctionNVX function, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::RenderPass >::type createRenderPass(const vk::RenderPassCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(const vk::DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< DataType, DataTypeAllocator > > getQueryPoolResults(vk::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, vk::DeviceSize stride, vk::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::MemoryHostPointerPropertiesEXT >::type getMemoryHostPointerPropertiesEXT(vk::ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void freeMemory(vk::DeviceMemory memory, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::DeviceMemory >::type allocateMemory(const vk::MemoryAllocateInfo &allocateInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyDeferredOperationKHR(vk::DeferredOperationKHR operation, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyBuffer(vk::Buffer buffer, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getBufferMemoryRequirementsKHR(const vk::DeviceBufferMemoryRequirements *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getBufferMemoryRequirements(const vk::DeviceBufferMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::CuFunctionNVX >::type createCuFunctionNVX(const vk::CuFunctionCreateInfoNVX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::VideoSessionKHR >::type createVideoSessionKHR(const vk::VideoSessionCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result signalSemaphoreKHR(const vk::SemaphoreSignalInfo *pSignalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result deferredOperationJoinKHR(vk::DeferredOperationKHR operation, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createMicromapEXT(const vk::MicromapCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::MicromapEXT *pMicromap, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::RenderPass renderPass, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::SubresourceLayout2KHR getImageSubresourceLayout2KHR(vk::Image image, const vk::ImageSubresource2KHR &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::AccelerationStructureKHR accelerationStructure, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CommandBuffer, CommandBufferAllocator > >::type allocateCommandBuffers(const vk::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createSemaphore(const vk::SemaphoreCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Semaphore *pSemaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesKHRUnique(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getCudaModuleCacheNV(vk::CudaModuleNV module, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getDescriptorSetLayoutSupport(const vk::DescriptorSetLayoutCreateInfo *pCreateInfo, vk::DescriptorSetLayoutSupport *pSupport, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ShaderEXT, ShaderEXTAllocator > >::type createShadersEXT(vk::ArrayProxy< const vk::ShaderCreateInfoEXT > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, ShaderEXTAllocator &shaderEXTAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createVideoSessionKHR(const vk::VideoSessionCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::VideoSessionKHR *pVideoSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Pipeline pipeline, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SwapchainKHR, Dispatch > >::type createSharedSwapchainKHRUnique(const vk::SwapchainCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createRenderPass(const vk::RenderPassCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::DescriptorSetLayout descriptorSetLayout, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::VideoSessionParametersKHR, Dispatch > >::type createVideoSessionParametersKHRUnique(const vk::VideoSessionParametersCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::MicromapEXT >::type createMicromapEXT(const vk::MicromapCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR(const vk::AccelerationStructureVersionInfoKHR &versionInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type updateVideoSessionParametersKHR(vk::VideoSessionParametersKHR videoSessionParameters, const vk::VideoSessionParametersUpdateInfoKHR &updateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindVideoSessionMemoryKHR(vk::VideoSessionKHR videoSession, vk::ArrayProxy< const vk::BindVideoSessionMemoryInfoKHR > const &bindSessionMemoryInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::CudaFunctionNV function, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::AccelerationStructureKHR, Dispatch > >::type createAccelerationStructureKHRUnique(const vk::AccelerationStructureCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createSampler(const vk::SamplerCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Sampler *pSampler, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
uint64_t getMemoryOpaqueCaptureAddress(const vk::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Extent2D getRenderingAreaGranularityKHR(const vk::RenderingAreaInfoKHR &renderingAreaInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result setLatencySleepModeNV(vk::SwapchainKHR swapchain, const vk::LatencySleepModeInfoNV *pSleepModeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void uninitializePerformanceApiINTEL(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
uint64_t getBufferOpaqueCaptureAddressKHR(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV(vk::CudaModuleNV module, size_t *pCacheSize, void *pCacheData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::ShaderEXT, Dispatch >, ShaderEXTAllocator > >::type createShadersEXTUnique(vk::ArrayProxy< const vk::ShaderCreateInfoEXT > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::RayTracingPipelineCreateInfoKHR *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageViewAddressPropertiesNVX >::type getImageViewAddressNVX(vk::ImageView imageView, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::DeviceGroupPresentCapabilitiesKHR >::type getGroupPresentCapabilitiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getImageSparseMemoryRequirements2KHR(const vk::ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::ValidationCacheEXT, Dispatch > >::type createValidationCacheEXTUnique(const vk::ValidationCacheCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(vk::ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, vk::MemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements2KHR(const vk::ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::PerformanceValueINTEL >::type getPerformanceParameterINTEL(vk::PerformanceParameterTypeINTEL parameter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::SwapchainKHR, Dispatch >, SwapchainKHRAllocator > >::type createSharedSwapchainsKHRUnique(vk::ArrayProxy< const vk::SwapchainCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyIndirectCommandsLayoutNV(vk::IndirectCommandsLayoutNV indirectCommandsLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DescriptorPool, Dispatch > >::type createDescriptorPoolUnique(const vk::DescriptorPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutableInternalRepresentationKHR, PipelineExecutableInternalRepresentationKHRAllocator > >::type getPipelineExecutableInternalRepresentationsKHR(const vk::PipelineExecutableInfoKHR &executableInfo, PipelineExecutableInternalRepresentationKHRAllocator &pipelineExecutableInternalRepresentationKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR(const vk::VideoSessionParametersCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::VideoSessionParametersKHR *pVideoSessionParameters, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result resetFences(uint32_t fenceCount, const vk::Fence *pFences, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< void * >::type mapMemory2KHR(const vk::MemoryMapInfoKHR &memoryMapInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR(vk::VideoSessionParametersKHR videoSessionParameters, const vk::VideoSessionParametersUpdateInfoKHR *pUpdateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::RenderPass >::type createRenderPass2(const vk::RenderPassCreateInfo2 &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getImageMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createImage(const vk::ImageCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Image *pImage, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPipeline(vk::Pipeline pipeline, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type compileDeferredNV(vk::Pipeline pipeline, uint32_t shader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyShaderEXT(vk::ShaderEXT shader, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DeferredOperationKHR, Dispatch > >::type createDeferredOperationKHRUnique(Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindBufferMemory2(vk::ArrayProxy< const vk::BindBufferMemoryInfo > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getBufferMemoryRequirements(const vk::DeviceBufferMemoryRequirements *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::ShaderEXT >::type createShaderEXT(const vk::ShaderCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::Result copyMemoryToAccelerationStructureKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyMemoryToAccelerationStructureInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createComputePipeline(vk::PipelineCache pipelineCache, const vk::ComputePipelineCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getImageSubresourceLayout(vk::Image image, const vk::ImageSubresource *pSubresource, vk::SubresourceLayout *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createBuffer(const vk::BufferCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Buffer *pBuffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createCudaModuleNV(const vk::CudaModuleCreateInfoNV *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::CudaModuleNV *pModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDescriptorSetLayout(vk::DescriptorSetLayout descriptorSetLayout, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::DeviceSize getDescriptorSetLayoutBindingOffsetEXT(vk::DescriptorSetLayout layout, uint32_t binding, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type setPrivateDataEXT(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getImageMemoryRequirements(const vk::DeviceImageMemoryRequirements *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::PrivateDataSlot privateDataSlot, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(const vk::GeneratedCommandsMemoryRequirementsInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createComputePipelines(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ComputePipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingCaptureReplayShaderGroupHandleKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
uint64_t getBufferOpaqueCaptureAddress(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Result getDynamicRenderingTilePropertiesQCOM(const vk::RenderingInfo *pRenderingInfo, vk::TilePropertiesQCOM *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::ImageView imageView, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::MicromapEXT micromap, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::CommandPool >::type createCommandPool(const vk::CommandPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type writeMicromapsPropertyEXT(vk::ArrayProxy< const vk::MicromapEXT > const &micromaps, vk::QueryType queryType, size_t stride, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::SamplerYcbcrConversion >::type createSamplerYcbcrConversionKHR(const vk::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT(vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type setPrivateData(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(vk::RenderPass renderpass, vk::Extent2D *pMaxWorkgroupSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createExecutionGraphPipelinesAMDXUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ExecutionGraphPipelineCreateInfoAMDX > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::CudaFunctionNV, Dispatch > >::type createCudaFunctionNVUnique(const vk::CudaFunctionCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void freeCommandBuffers(vk::CommandPool commandPool, vk::ArrayProxy< const vk::CommandBuffer > const &commandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::ShaderModule shaderModule, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyQueryPool(vk::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TilePropertiesQCOM, TilePropertiesQCOMAllocator > >::type getFramebufferTilePropertiesQCOM(vk::Framebuffer framebuffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createEvent(const vk::EventCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Event *pEvent, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createGraphicsPipelinesUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::GraphicsPipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getDescriptorEXT(const vk::DescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirements2(const vk::ImageMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TilePropertiesQCOM, TilePropertiesQCOMAllocator > >::type getFramebufferTilePropertiesQCOM(vk::Framebuffer framebuffer, TilePropertiesQCOMAllocator &tilePropertiesQCOMAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator > getImageSparseMemoryRequirements(vk::Image image, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< uint64_t, Uint64_tAllocator >, uint64_t > >::type getCalibratedTimestampsEXT(vk::ArrayProxy< const vk::CalibratedTimestampInfoKHR > const &timestampInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
ResultValueType< void >::type resetFences(vk::ArrayProxy< const vk::Fence > const &fences, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::IndirectCommandsLayoutNV, Dispatch > >::type createIndirectCommandsLayoutNVUnique(const vk::IndirectCommandsLayoutCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::CuModuleNVX >::type createCuModuleNVX(const vk::CuModuleCreateInfoNVX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesKHRUnique(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::Framebuffer framebuffer, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyPipeline(vk::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyRenderPass(vk::RenderPass renderPass, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(const vk::SamplerYcbcrConversionCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySemaphore(vk::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::AccelerationStructureKHR accelerationStructure, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(const vk::DescriptorSetLayoutCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DescriptorSetLayout *pSetLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(vk::Image image, vk::ImageDrmFormatModifierPropertiesEXT *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type getRayTracingShaderGroupHandlesKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createCommandPool(const vk::CommandPoolCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::CommandPool *pCommandPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createShadersEXT(uint32_t createInfoCount, const vk::ShaderCreateInfoEXT *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::ShaderEXT *pShaders, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySamplerYcbcrConversion(vk::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator > >::type getPipelineExecutableStatisticsKHR(const vk::PipelineExecutableInfoKHR &executableInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!=(Device const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8818
VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< int >::type getMemoryFdKHR(const vk::MemoryGetFdInfoKHR &getFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges(uint32_t memoryRangeCount, const vk::MappedMemoryRange *pMemoryRanges, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type latencySleepNV(vk::SwapchainKHR swapchain, const vk::LatencySleepInfoNV &sleepInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::Sampler sampler, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result getSwapchainStatusKHR(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PipelineCache, Dispatch > >::type createPipelineCacheUnique(const vk::PipelineCacheCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::CuFunctionNVX function, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::CommandBuffer, Dispatch >, CommandBufferAllocator > >::type allocateCommandBuffersUnique(const vk::CommandBufferAllocateInfo &allocateInfo, CommandBufferAllocator &commandBufferAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
Result unmapMemory2KHR(const vk::MemoryUnmapInfoKHR *pMemoryUnmapInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createCudaFunctionNV(const vk::CudaFunctionCreateInfoNV *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::CudaFunctionNV *pFunction, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ShaderEXT, ShaderEXTAllocator > >::type createShadersEXT(vk::ArrayProxy< const vk::ShaderCreateInfoEXT > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::Result getEventStatus(vk::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result waitSemaphoresKHR(const vk::SemaphoreWaitInfo *pWaitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< uint64_t, Uint64_tAllocator >, uint64_t > >::type getCalibratedTimestampsKHR(vk::ArrayProxy< const vk::CalibratedTimestampInfoKHR > const &timestampInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::DeferredOperationKHR operation, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type copyImageToMemoryEXT(const vk::CopyImageToMemoryInfoEXT &copyImageToMemoryInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT(const vk::CopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< vk::StructureChain< X, Y, Z... >, std::vector< uint8_t, Uint8_tAllocator > > >::type getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR &videoSessionParametersInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getPrivateData(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, uint64_t *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Result freeDescriptorSets(vk::DescriptorPool descriptorPool, uint32_t descriptorSetCount, const vk::DescriptorSet *pDescriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDescriptorUpdateTemplate(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::SubresourceLayout getImageSubresourceLayout(vk::Image image, const vk::ImageSubresource &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getGeneratedCommandsMemoryRequirementsNV(const vk::GeneratedCommandsMemoryRequirementsInfoNV *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result waitForFences(vk::ArrayProxy< const vk::Fence > const &fences, vk::Bool32 waitAll, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PerformanceConfigurationINTEL, Dispatch > >::type acquirePerformanceConfigurationINTELUnique(const vk::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(vk::VideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const vk::BindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::CommandPool commandPool, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageSubresourceLayout2KHR(vk::Image image, const vk::ImageSubresource2KHR &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirementsKHR(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::Fence fence, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VkDevice CType
Definition: vulkan_handles.hpp:8784
VULKAN_HPP_NODISCARD vk::ShaderModuleIdentifierEXT getShaderModuleIdentifierEXT(vk::ShaderModule shaderModule, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT(const vk::ImageCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyFence(vk::Fence fence, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageSubresourceLayout2EXT(vk::Image image, const vk::ImageSubresource2KHR *pSubresource, vk::SubresourceLayout2KHR *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createComputePipelines(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ComputePipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(const vk::DescriptorUpdateTemplateCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT(const vk::PipelineInfoEXT *pPipelineInfo, vk::BaseOutStructure *pPipelineProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyMicromapEXT(vk::MicromapEXT micromap, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements2 getBufferMemoryRequirementsKHR(const vk::DeviceBufferMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type mergeValidationCachesEXT(vk::ValidationCacheEXT dstCache, vk::ArrayProxy< const vk::ValidationCacheEXT > const &srcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::IndirectCommandsLayoutNV indirectCommandsLayout, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySwapchainKHR(vk::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::CommandPool commandPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator > >::type getPipelineExecutablePropertiesKHR(const vk::PipelineInfoKHR &pipelineInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT(const vk::MicromapVersionInfoEXT &versionInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(const vk::PipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, vk::PipelineExecutablePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyImage(vk::Image image, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(const vk::PipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, vk::PipelineExecutableInternalRepresentationKHR *pInternalRepresentations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
uint64_t getBufferOpaqueCaptureAddress(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeviceSize getRayTracingShaderGroupStackSizeKHR(vk::Pipeline pipeline, uint32_t group, vk::ShaderGroupShaderKHR groupShader, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::IndirectCommandsLayoutNV >::type createIndirectCommandsLayoutNV(const vk::IndirectCommandsLayoutCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::CudaModuleNV, Dispatch > >::type createCudaModuleNVUnique(const vk::CudaModuleCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySampler(vk::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::TilePropertiesQCOM getDynamicRenderingTilePropertiesQCOM(const vk::RenderingInfo &renderingInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::DescriptorPool descriptorPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result getFenceStatus(vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
vk::DeviceAddress getBufferAddress(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, vk::Queue *pQueue, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::CudaModuleNV module, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirements2(const vk::BufferMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getPipelineIndirectMemoryRequirementsNV(const vk::ComputePipelineCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::RemoteAddressNV >::type getMemoryRemoteAddressNV(const vk::MemoryGetRemoteAddressInfoNV &memoryGetRemoteAddressInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result allocateCommandBuffers(const vk::CommandBufferAllocateInfo *pAllocateInfo, vk::CommandBuffer *pCommandBuffers, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::ShaderModule >::type createShaderModule(const vk::ShaderModuleCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyAccelerationStructureToMemoryInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getBufferMemoryRequirements(vk::Buffer buffer, vk::MemoryRequirements *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::RenderPass, Dispatch > >::type createRenderPass2KHRUnique(const vk::RenderPassCreateInfo2 &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
uint32_t getImageViewHandleNVX(const vk::ImageViewHandleInfoNVX &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Device()=default
void getImageMemoryRequirements2KHR(const vk::ImageMemoryRequirementsInfo2 *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::DeferredOperationKHR operation, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::SubresourceLayout2KHR getImageSubresourceLayout2EXT(vk::Image image, const vk::ImageSubresource2KHR &subresource, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPipelineCacheData(vk::PipelineCache pipelineCache, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DescriptorSet, DescriptorSetAllocator > >::type allocateDescriptorSets(const vk::DescriptorSetAllocateInfo &allocateInfo, DescriptorSetAllocator &descriptorSetAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createExecutionGraphPipelinesAMDXUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::ExecutionGraphPipelineCreateInfoAMDX > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::Result waitSemaphoresKHR(const vk::SemaphoreWaitInfo &waitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator > >::type getPipelineExecutablePropertiesKHR(const vk::PipelineInfoKHR &pipelineInfo, PipelineExecutablePropertiesKHRAllocator &pipelineExecutablePropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
PFN_vkVoidFunction getProcAddr(const std::string &name, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Fence fence, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(vk::SwapchainKHR swapchain, uint32_t *pPresentationTimingCount, vk::PastPresentationTimingGOOGLE *pPresentationTimings, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type releaseSwapchainImagesEXT(const vk::ReleaseSwapchainImagesInfoEXT &releaseInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getImageOpaqueCaptureDescriptorDataEXT(const vk::ImageCaptureDescriptorDataInfoEXT &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< uint64_t >::type getSemaphoreCounterValueKHR(vk::Semaphore semaphore, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::OpticalFlowSessionNV session, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM(vk::Framebuffer framebuffer, uint32_t *pPropertiesCount, vk::TilePropertiesQCOM *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getDescriptorSetLayoutSupportKHR(const vk::DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::Buffer >::type createBuffer(const vk::BufferCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::BufferView bufferView, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(const vk::DescriptorUpdateTemplateCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::VideoSessionParametersKHR videoSessionParameters, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSwapchainKHR(const vk::SwapchainCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SwapchainKHR *pSwapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createGraphicsPipelines(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::GraphicsPipelineCreateInfo > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::Image, ImageAllocator > >::type getSwapchainImagesKHR(vk::SwapchainKHR swapchain, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::SamplerYcbcrConversion ycbcrConversion, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< int >::type getFenceFdKHR(const vk::FenceGetFdInfoKHR &getFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyDescriptorUpdateTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getDescriptorSetLayoutBindingOffsetEXT(vk::DescriptorSetLayout layout, uint32_t binding, vk::DeviceSize *pOffset, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::CudaModuleNV module, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::PerformanceConfigurationINTEL >::type acquirePerformanceConfigurationINTEL(const vk::PerformanceConfigurationAcquireInfoINTEL &acquireInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createFramebuffer(const vk::FramebufferCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Framebuffer *pFramebuffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createRenderPass2(const vk::RenderPassCreateInfo2 *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::RenderPass *pRenderPass, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
DeviceAddress getBufferAddress(const vk::BufferDeviceAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DescriptorSetLayout, Dispatch > >::type createDescriptorSetLayoutUnique(const vk::DescriptorSetLayoutCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
vk::DeviceAddress getPipelineIndirectAddressNV(const vk::PipelineIndirectDeviceAddressInfoNV &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyAccelerationStructureKHR(vk::AccelerationStructureKHR accelerationStructure, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createRayTracingPipelinesKHR(vk::DeferredOperationKHR deferredOperation, vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoKHR > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyBufferView(vk::BufferView bufferView, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDescriptorPool(vk::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type resetEvent(vk::Event event, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::Image, ImageAllocator > >::type getSwapchainImagesKHR(vk::SwapchainKHR swapchain, ImageAllocator &imageAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type copyMemoryToImageEXT(const vk::CopyMemoryToImageInfoEXT &copyMemoryToImageInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void resetDescriptorPool(vk::DescriptorPool descriptorPool, vk::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDescriptorUpdateTemplate(vk::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindImageMemory2KHR(vk::ArrayProxy< const vk::BindImageMemoryInfo > const &bindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR *pVideoSessionParametersInfo, vk::VideoEncodeSessionParametersFeedbackInfoKHR *pFeedbackInfo, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result waitSemaphores(const vk::SemaphoreWaitInfo *pWaitInfo, uint64_t timeout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyFence(vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getImageSubresourceLayoutKHR(const vk::DeviceImageSubresourceInfoKHR *pInfo, vk::SubresourceLayout2KHR *pLayout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getLatencyTimingsNV(vk::SwapchainKHR swapchain, vk::GetLatencyMarkerInfoNV *pLatencyMarkerInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::CommandBuffer, Dispatch >, CommandBufferAllocator > >::type allocateCommandBuffersUnique(const vk::CommandBufferAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::Image >::type createImage(const vk::ImageCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionUnique(const vk::SamplerYcbcrConversionCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getDescriptorEXT(const vk::DescriptorGetInfoEXT &descriptorInfo, size_t dataSize, void *pDescriptor, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getValidationCacheDataEXT(vk::ValidationCacheEXT validationCache, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::ShaderEXT shader, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::PrivateDataSlot >::type createPrivateDataSlotEXT(const vk::PrivateDataSlotCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::PrivateDataSlot, Dispatch > >::type createPrivateDataSlotEXTUnique(const vk::PrivateDataSlotCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageSubresourceLayoutKHR(const vk::DeviceImageSubresourceInfoKHR &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< vk::Pipeline > createRayTracingPipelineNV(vk::PipelineCache pipelineCache, const vk::RayTracingPipelineCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements2(const vk::ImageSparseMemoryRequirementsInfo2 &info, SparseImageMemoryRequirements2Allocator &sparseImageMemoryRequirements2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
uint64_t getMemoryOpaqueCaptureAddress(const vk::DeviceMemoryOpaqueCaptureAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR(const vk::AcquireProfilingLockInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Fence, Dispatch > >::type registerDisplayEventEXTUnique(vk::DisplayKHR display, const vk::DisplayEventInfoEXT &displayEventInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result mergePipelineCaches(vk::PipelineCache dstCache, uint32_t srcCacheCount, const vk::PipelineCache *pSrcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, vk::PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyRenderPass(vk::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createQueryPool(const vk::QueryPoolCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::QueryPool *pQueryPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Buffer, Dispatch > >::type createBufferUnique(const vk::BufferCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(const vk::DebugMarkerObjectTagInfoEXT *pTagInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Semaphore semaphore, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::PipelineCache pipelineCache, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDescriptorSetLayout(vk::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements getBufferMemoryRequirements(vk::Buffer buffer, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result acquireNextImageKHR(vk::SwapchainKHR swapchain, uint64_t timeout, vk::Semaphore semaphore, vk::Fence fence, uint32_t *pImageIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
uint32_t getImageViewHandleNVX(const vk::ImageViewHandleInfoNVX *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
uint64_t getMemoryOpaqueCaptureAddressKHR(const vk::DeviceMemoryOpaqueCaptureAddressInfo *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT(vk::ValidationCacheEXT dstCache, uint32_t srcCacheCount, const vk::ValidationCacheEXT *pSrcCaches, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< uint64_t >::type getSwapchainCounterEXT(vk::SwapchainKHR swapchain, vk::SurfaceCounterFlagBitsEXT counter, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV(const vk::MemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, vk::RemoteAddressNV *pAddress, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::ImageView, Dispatch > >::type createImageViewUnique(const vk::ImageViewCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::QueryPool >::type createQueryPool(const vk::QueryPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT(uint32_t transitionCount, const vk::HostImageLayoutTransitionInfoEXT *pTransitions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createGraphicsPipelines(vk::PipelineCache pipelineCache, uint32_t createInfoCount, const vk::GraphicsPipelineCreateInfo *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::Pipeline *pPipelines, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< vk::StructureChain< X, Y, Z... >, std::vector< uint8_t, Uint8_tAllocator > > >::type getEncodedVideoSessionParametersKHR(const vk::VideoEncodeSessionParametersGetInfoKHR &videoSessionParametersInfo, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
vk::DeviceAddress getBufferAddressEXT(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator > getImageSparseMemoryRequirements(vk::Image image, SparseImageMemoryRequirementsAllocator &sparseImageMemoryRequirementsAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< std::vector< UniqueHandle< vk::Pipeline, Dispatch >, PipelineAllocator > > createRayTracingPipelinesNVUnique(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void updateDescriptorSetWithTemplate(vk::DescriptorSet descriptorSet, vk::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const &data, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createRayTracingPipelinesNV(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const vk::AllocationCallbacks > allocator, PipelineAllocator &pipelineAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR(vk::SwapchainKHR swapchain, uint32_t *pSwapchainImageCount, vk::Image *pSwapchainImages, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::MemoryRequirements getImageMemoryRequirements(vk::Image image, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::OpticalFlowSessionNV session, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirements2KHR(const vk::BufferMemoryRequirementsInfo2 &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SwapchainKHR, Dispatch > >::type createSwapchainKHRUnique(const vk::SwapchainCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Queue getQueue2(const vk::DeviceQueueInfo2 &queueInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getFaultInfoEXT(vk::DeviceFaultCountsEXT *pFaultCounts, vk::DeviceFaultInfoEXT *pFaultInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyVideoSessionKHR(vk::VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroySwapchainKHR(vk::SwapchainKHR swapchain, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Image image, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageView >::type createImageView(const vk::ImageViewCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setDebugUtilsObjectNameEXT(const vk::DebugUtilsObjectNameInfoEXT &nameInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getImageMemoryRequirements2(const vk::ImageMemoryRequirementsInfo2 *pInfo, vk::MemoryRequirements2 *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::QueryPool, Dispatch > >::type createQueryPoolUnique(const vk::QueryPoolCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator > getImageSparseMemoryRequirements(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createDescriptorPool(const vk::DescriptorPoolCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DescriptorPool *pDescriptorPool, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::AccelerationStructureKHR >::type createAccelerationStructureKHR(const vk::AccelerationStructureCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT(const vk::SamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getDescriptorSetHostMappingVALVE(vk::DescriptorSet descriptorSet, void **ppData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyFramebuffer(vk::Framebuffer framebuffer, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::Result buildMicromapsEXT(vk::DeferredOperationKHR deferredOperation, vk::ArrayProxy< const vk::MicromapBuildInfoEXT > const &infos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::OpticalFlowSessionNV >::type createOpticalFlowSessionNV(const vk::OpticalFlowSessionCreateInfoNV &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
uint64_t getMemoryOpaqueCaptureAddressKHR(const vk::DeviceMemoryOpaqueCaptureAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void freeDescriptorSets(vk::DescriptorPool descriptorPool, vk::ArrayProxy< const vk::DescriptorSet > const &descriptorSets, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::VideoSessionKHR videoSession, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::Semaphore >::type createSemaphore(const vk::SemaphoreCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyQueryPool(vk::QueryPool queryPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createComputePipelineUnique(vk::PipelineCache pipelineCache, const vk::ComputePipelineCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(vk::ValidationCacheEXT validationCache, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(vk::VideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, vk::VideoSessionMemoryRequirementsKHR *pMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirements(const vk::DeviceImageMemoryRequirements &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< DataType >::type getRayTracingShaderGroupHandleKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValue< UniqueHandle< vk::Pipeline, Dispatch > > createExecutionGraphPipelineAMDXUnique(vk::PipelineCache pipelineCache, const vk::ExecutionGraphPipelineCreateInfoAMDX &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX(vk::Pipeline executionGraph, const vk::PipelineShaderStageNodeCreateInfoAMDX *pNodeInfo, uint32_t *pNodeIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type signalSemaphoreKHR(const vk::SemaphoreSignalInfo &signalInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getImageSparseMemoryRequirements(const vk::DeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, vk::SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getRenderingAreaGranularityKHR(const vk::RenderingAreaInfoKHR *pRenderingAreaInfo, vk::Extent2D *pGranularity, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type importFenceFdKHR(const vk::ImportFenceFdInfoKHR &importFenceFdInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyBuffer(vk::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::DeviceSize getDescriptorSetLayoutSizeEXT(vk::DescriptorSetLayout layout, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::QueryPool queryPool, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV(const vk::OpticalFlowSessionCreateInfoNV *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::OpticalFlowSessionNV *pSession, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValue< std::vector< vk::Pipeline, PipelineAllocator > > createRayTracingPipelinesNV(vk::PipelineCache pipelineCache, vk::ArrayProxy< const vk::RayTracingPipelineCreateInfoNV > const &createInfos, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result bindImageMemory2KHR(uint32_t bindInfoCount, const vk::BindImageMemoryInfo *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type releasePerformanceConfigurationINTEL(vk::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< uint8_t, Uint8_tAllocator > >::type getPipelineCacheData(vk::PipelineCache pipelineCache, Uint8_tAllocator &uint8_tAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< DataType, DataTypeAllocator > >::type getRayTracingCaptureReplayShaderGroupHandlesKHR(vk::Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::Fence >::type registerEventEXT(const vk::DeviceEventInfoEXT &deviceEventInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT(vk::ShaderEXT shader, size_t *pDataSize, void *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyCudaFunctionNV(vk::CudaFunctionNV function, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Device & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8804
VULKAN_HPP_NODISCARD ResultValueType< std::vector< UniqueHandle< vk::DescriptorSet, Dispatch >, DescriptorSetAllocator > >::type allocateDescriptorSetsUnique(const vk::DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyIndirectCommandsLayoutNV(vk::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::PrivateDataSlot privateDataSlot, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
vk::DeviceAddress getBufferAddressKHR(const vk::BufferDeviceAddressInfo &info, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateUnique(const vk::DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(vk::DeferredOperationKHR deferredOperation, const vk::CopyMemoryToAccelerationStructureInfoKHR *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(uint32_t swapchainCount, const vk::SwapchainCreateInfoKHR *pCreateInfos, const vk::AllocationCallbacks *pAllocator, vk::SwapchainKHR *pSwapchains, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::Sampler sampler, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getPrivateDataEXT(vk::ObjectType objectType_, uint64_t objectHandle, vk::PrivateDataSlot privateDataSlot, uint64_t *pData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR(vk::ExternalMemoryHandleTypeFlagBits handleType, int fd, vk::MemoryFdPropertiesKHR *pMemoryFdProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result copyMicromapEXT(vk::DeferredOperationKHR deferredOperation, const vk::CopyMicromapInfoEXT *pInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(uint32_t bindInfoCount, const vk::BindAccelerationStructureMemoryInfoNV *pBindInfos, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2616
DisplayKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2640
VULKAN_HPP_CONSTEXPR DisplayKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2628
bool operator==(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2649
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2675
bool operator!=(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2654
bool operator<(DisplayKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2659
VULKAN_HPP_CONSTEXPR DisplayKHR()=default
VkDisplayKHR NativeType
Definition: vulkan_handles.hpp:2619
VkDisplayKHR CType
Definition: vulkan_handles.hpp:2618
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR(VkDisplayKHR displayKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2630
Definition: vulkan_handles.hpp:13920
VULKAN_HPP_CONSTEXPR DisplayModeKHR()=default
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR(VkDisplayModeKHR displayModeKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13934
DisplayModeKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13944
VkDisplayModeKHR CType
Definition: vulkan_handles.hpp:13922
VkDisplayModeKHR NativeType
Definition: vulkan_handles.hpp:13923
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13979
bool operator==(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13953
bool operator<(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13963
bool operator!=(DisplayModeKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13958
VULKAN_HPP_CONSTEXPR DisplayModeKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:13932
Definition: vulkan_handles.hpp:4004
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4063
VkEvent CType
Definition: vulkan_handles.hpp:4006
VULKAN_HPP_CONSTEXPR Event()=default
VULKAN_HPP_CONSTEXPR Event(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4016
bool operator!=(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4042
VULKAN_HPP_TYPESAFE_EXPLICIT Event(VkEvent event) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4018
Event & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4028
VkEvent NativeType
Definition: vulkan_handles.hpp:4007
bool operator==(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4037
bool operator<(Event const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4047
Definition: vulkan_handles.hpp:2877
VkFence NativeType
Definition: vulkan_handles.hpp:2880
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2936
bool operator<(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2920
VULKAN_HPP_CONSTEXPR Fence(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2889
bool operator==(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2910
VULKAN_HPP_TYPESAFE_EXPLICIT Fence(VkFence fence) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2891
VULKAN_HPP_CONSTEXPR Fence()=default
Fence & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2901
VkFence CType
Definition: vulkan_handles.hpp:2879
bool operator!=(Fence const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2915
Definition: vulkan_handles.hpp:7757
bool operator==(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7790
bool operator!=(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7795
VkFramebuffer CType
Definition: vulkan_handles.hpp:7759
VkFramebuffer NativeType
Definition: vulkan_handles.hpp:7760
Framebuffer & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7781
VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer(VkFramebuffer framebuffer) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7771
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7816
bool operator<(Framebuffer const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7800
VULKAN_HPP_CONSTEXPR Framebuffer()=default
VULKAN_HPP_CONSTEXPR Framebuffer(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7769
Definition: vulkan_handles.hpp:3396
bool operator==(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3429
VULKAN_HPP_CONSTEXPR ImageView(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3408
VULKAN_HPP_TYPESAFE_EXPLICIT ImageView(VkImageView imageView) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3410
VkImageView CType
Definition: vulkan_handles.hpp:3398
VULKAN_HPP_CONSTEXPR ImageView()=default
ImageView & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3420
bool operator<(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3439
bool operator!=(ImageView const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3434
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3455
VkImageView NativeType
Definition: vulkan_handles.hpp:3399
Definition: vulkan_handles.hpp:3651
bool operator!=(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3689
bool operator<(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3694
VkImage NativeType
Definition: vulkan_handles.hpp:3654
VULKAN_HPP_TYPESAFE_EXPLICIT Image(VkImage image) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3665
bool operator==(Image const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3684
VkImage CType
Definition: vulkan_handles.hpp:3653
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3710
VULKAN_HPP_CONSTEXPR Image(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3663
VULKAN_HPP_CONSTEXPR Image()=default
Image & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3675
Definition: vulkan_handles.hpp:7844
VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7858
bool operator<(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7890
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7906
VkIndirectCommandsLayoutNV CType
Definition: vulkan_handles.hpp:7846
bool operator!=(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7885
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7856
bool operator==(IndirectCommandsLayoutNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7880
VkIndirectCommandsLayoutNV NativeType
Definition: vulkan_handles.hpp:7847
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV()=default
IndirectCommandsLayoutNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7871
Definition: vulkan_handles.hpp:15429
Instance(VkInstance instance) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15443
bool operator<(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15470
void destroy(vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Instance & operator=(VkInstance instance) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15445
VULKAN_HPP_NODISCARD ResultValueType< vk::DebugUtilsMessengerEXT >::type createDebugUtilsMessengerEXT(const vk::DebugUtilsMessengerCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDevice, PhysicalDeviceAllocator > >::type enumeratePhysicalDevices(PhysicalDeviceAllocator &physicalDeviceAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT(const vk::HeadlessSurfaceCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SurfaceKHR *pSurface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(uint32_t *pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(const vk::DebugUtilsMessengerCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DebugUtilsMessengerEXT *pMessenger, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Instance(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15441
void debugReportMessageEXT(vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType_, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void submitDebugUtilsMessageEXT(vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const vk::DebugUtilsMessengerCallbackDataEXT &callbackData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VkInstance NativeType
Definition: vulkan_handles.hpp:15432
void debugReportMessageEXT(vk::DebugReportFlagsEXT flags, vk::DebugReportObjectTypeEXT objectType_, uint64_t object, size_t location, int32_t messageCode, const std::string &layerPrefix, const std::string &message, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceKHR >::type createDisplayPlaneSurfaceKHR(const vk::DisplaySurfaceCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::DebugUtilsMessengerEXT messenger, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DebugUtilsMessengerEXT, Dispatch > >::type createDebugUtilsMessengerEXTUnique(const vk::DebugUtilsMessengerCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDevice, PhysicalDeviceAllocator > >::type enumeratePhysicalDevices(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SurfaceKHR, Dispatch > >::type createDisplayPlaneSurfaceKHRUnique(const vk::DisplaySurfaceCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(uint32_t *pPhysicalDeviceGroupCount, vk::PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices(uint32_t *pPhysicalDeviceCount, vk::PhysicalDevice *pPhysicalDevices, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VkInstance CType
Definition: vulkan_handles.hpp:15431
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DebugReportCallbackEXT, Dispatch > >::type createDebugReportCallbackEXTUnique(const vk::DebugReportCallbackCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Instance()=default
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::SurfaceKHR, Dispatch > >::type createHeadlessSurfaceEXTUnique(const vk::HeadlessSurfaceCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroyDebugReportCallbackEXT(vk::DebugReportCallbackEXT callback, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::SurfaceKHR surface, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Instance & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15451
void destroyDebugUtilsMessengerEXT(vk::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroy(vk::DebugReportCallbackEXT callback, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PFN_vkVoidFunction getProcAddr(const std::string &name, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator==(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15460
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator > >::type enumeratePhysicalDeviceGroups(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroy(vk::SurfaceKHR surface, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDebugReportCallbackEXT(vk::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:16067
VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(const vk::DebugReportCallbackCreateInfoEXT *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DebugReportCallbackEXT *pCallback, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!=(Instance const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15465
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceKHR >::type createHeadlessSurfaceEXT(const vk::HeadlessSurfaceCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroySurfaceKHR(vk::SurfaceKHR surface, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator > >::type enumeratePhysicalDeviceGroupsKHR(PhysicalDeviceGroupPropertiesAllocator &physicalDeviceGroupPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator > >::type enumeratePhysicalDeviceGroups(PhysicalDeviceGroupPropertiesAllocator &physicalDeviceGroupPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void destroySurfaceKHR(vk::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(const vk::DisplaySurfaceCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::SurfaceKHR *pSurface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void destroyDebugUtilsMessengerEXT(vk::DebugUtilsMessengerEXT messenger, const vk::AllocationCallbacks *pAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::DebugReportCallbackEXT >::type createDebugReportCallbackEXT(const vk::DebugReportCallbackCreateInfoEXT &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator > >::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void submitDebugUtilsMessageEXT(vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageTypes, const vk::DebugUtilsMessengerCallbackDataEXT *pCallbackData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4181
VULKAN_HPP_CONSTEXPR MicromapEXT()=default
VkMicromapEXT CType
Definition: vulkan_handles.hpp:4183
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4240
bool operator<(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4224
VkMicromapEXT NativeType
Definition: vulkan_handles.hpp:4184
VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT(VkMicromapEXT micromapEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4195
VULKAN_HPP_CONSTEXPR MicromapEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4193
bool operator!=(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4219
bool operator==(MicromapEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4214
MicromapEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:4205
Definition: vulkan.hpp:5960
Definition: vulkan.hpp:5914
Definition: vulkan.hpp:5996
Definition: vulkan_handles.hpp:3828
VkOpticalFlowSessionNV NativeType
Definition: vulkan_handles.hpp:3831
bool operator==(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3864
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV()=default
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3890
VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV(VkOpticalFlowSessionNV opticalFlowSessionNV) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3842
OpticalFlowSessionNV & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3855
bool operator<(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3874
bool operator!=(OpticalFlowSessionNV const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3869
VkOpticalFlowSessionNV CType
Definition: vulkan_handles.hpp:3830
VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3840
Definition: vulkan.hpp:567
Definition: vulkan_handles.hpp:2964
bool operator!=(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3005
bool operator<(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3010
VkPerformanceConfigurationINTEL NativeType
Definition: vulkan_handles.hpp:2967
VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2978
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2976
VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL()=default
VkPerformanceConfigurationINTEL CType
Definition: vulkan_handles.hpp:2966
PerformanceConfigurationINTEL & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2991
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3026
bool operator==(PerformanceConfigurationINTEL const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3000
Definition: vulkan_handles.hpp:14007
VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, uint32_t *pDisplayCount, vk::DisplayKHR *pDisplays, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::FormatProperties2 getFormatProperties2KHR(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, vk::SurfaceCapabilities2KHR *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::Rect2D, Rect2DAllocator > >::type getPresentRectanglesKHR(vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getProperties(vk::PhysicalDeviceProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayProperties2KHR, DisplayProperties2KHRAllocator > >::type getDisplayProperties2KHR(DisplayProperties2KHRAllocator &displayProperties2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getFormatProperties2KHR(vk::Format format, vk::FormatProperties2 *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14023
VULKAN_HPP_NODISCARD vk::PhysicalDeviceProperties2 getProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getExternalFencePropertiesKHR(const vk::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, vk::ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getFormatProperties2KHR(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getExternalSemaphoreProperties(const vk::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:15401
VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR(uint32_t *pTimeDomainCount, vk::TimeDomainKHR *pTimeDomains, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR(const vk::DisplayPlaneInfo2KHR *pDisplayPlaneInfo, vk::DisplayPlaneCapabilities2KHR *pCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator > >::type getSupportedFramebufferMixedSamplesCombinationsNV(FramebufferMixedSamplesCombinationNVAllocator &framebufferMixedSamplesCombinationNVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::VideoEncodeQualityLevelPropertiesKHR >::type getVideoEncodeQualityLevelPropertiesKHR(const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR &qualityLevelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator > getSparseImageFormatProperties(vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, SparseImageFormatPropertiesAllocator &sparseImageFormatPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PresentModeKHR, PresentModeKHRAllocator > >::type getSurfacePresentModesKHR(vk::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator > >::type getCooperativeMatrixPropertiesNV(CooperativeMatrixPropertiesNVAllocator &cooperativeMatrixPropertiesNVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator > getSparseImageFormatProperties2(const vk::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getFeatures(vk::PhysicalDeviceFeatures *pFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator > >::type getDisplayPlanePropertiesKHR(DisplayPlanePropertiesKHRAllocator &displayPlanePropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::Rect2D, Rect2DAllocator > >::type getPresentRectanglesKHR(vk::SurfaceKHR surface, Rect2DAllocator &rect2DAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getMemoryProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::ExternalBufferProperties getExternalBufferProperties(const vk::PhysicalDeviceExternalBufferInfo &externalBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getQueueFamilyProperties2(uint32_t *pQueueFamilyPropertyCount, vk::QueueFamilyProperties2 *pQueueFamilyProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator > >::type getCooperativeMatrixPropertiesNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator > >::type getDisplayPropertiesKHR(DisplayPropertiesKHRAllocator &displayPropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::DisplayKHR >::type getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(vk::SurfaceKHR surface, vk::SurfaceCapabilities2EXT *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDevice()=default
VULKAN_HPP_CONSTEXPR PhysicalDevice(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14019
void getExternalBufferProperties(const vk::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, vk::ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::VideoCapabilitiesKHR >::type getVideoCapabilitiesKHR(const vk::VideoProfileInfoKHR &videoProfile, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VkPhysicalDevice CType
Definition: vulkan_handles.hpp:14009
void getSparseImageFormatProperties(vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, uint32_t *pPropertyCount, vk::SparseImageFormatProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR(vk::SurfaceKHR surface, uint32_t *pSurfaceFormatCount, vk::SurfaceFormatKHR *pSurfaceFormats, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(uint32_t *pPropertyCount, vk::DisplayPlanePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getFormatProperties(vk::Format format, vk::FormatProperties *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator > >::type getDisplayPlaneProperties2KHR(DisplayPlaneProperties2KHRAllocator &displayPlaneProperties2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getQueueFamilyProperties(uint32_t *pQueueFamilyPropertyCount, vk::QueueFamilyProperties *pQueueFamilyProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator > >::type getToolPropertiesEXT(PhysicalDeviceToolPropertiesAllocator &physicalDeviceToolPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< StructureChain, StructureChainAllocator > getQueueFamilyProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Device, Dispatch > >::type createDeviceUnique(const vk::DeviceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
PhysicalDevice(VkPhysicalDevice physicalDevice) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14021
void getProperties2(vk::PhysicalDeviceProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< StructureChain, StructureChainAllocator > getQueueFamilyProperties2(StructureChainAllocator &structureChainAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV(const vk::OpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, vk::OpticalFlowImageFormatPropertiesNV *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getVideoEncodeQualityLevelPropertiesKHR(const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR &qualityLevelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VkPhysicalDevice NativeType
Definition: vulkan_handles.hpp:14010
VULKAN_HPP_NODISCARD vk::PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(const vk::PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, vk::ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TimeDomainKHR, TimeDomainKHRAllocator > >::type getCalibrateableTimeDomainsKHR(TimeDomainKHRAllocator &timeDomainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ExtensionProperties, ExtensionPropertiesAllocator > >::type enumerateDeviceExtensionProperties(Optional< const std::string > layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::DisplayPlaneCapabilities2KHR >::type getDisplayPlaneCapabilities2KHR(const vk::DisplayPlaneInfo2KHR &displayPlaneInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties2, QueueFamilyProperties2Allocator > getQueueFamilyProperties2KHR(QueueFamilyProperties2Allocator &queueFamilyProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator > >::type getDisplayPlanePropertiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TimeDomainKHR, TimeDomainKHRAllocator > >::type getCalibrateableTimeDomainsKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator > getSparseImageFormatProperties2(const vk::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, SparseImageFormatProperties2Allocator &sparseImageFormatProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getImageFormatProperties2KHR(const vk::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SurfaceFormatKHR, SurfaceFormatKHRAllocator > >::type getSurfaceFormatsKHR(vk::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceCapabilities2EXT >::type getSurfaceCapabilities2EXT(vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SurfaceFormatKHR, SurfaceFormatKHRAllocator > >::type getSurfaceFormatsKHR(vk::SurfaceKHR surface, SurfaceFormatKHRAllocator &surfaceFormatKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator > >::type getFragmentShadingRatesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator > >::type getFragmentShadingRatesKHR(PhysicalDeviceFragmentShadingRateKHRAllocator &physicalDeviceFragmentShadingRateKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(const vk::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::ExternalFenceProperties getExternalFencePropertiesKHR(const vk::PhysicalDeviceExternalFenceInfo &externalFenceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::DisplayModeKHR >::type createDisplayModeKHR(vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(vk::SurfaceKHR surface, vk::SurfaceCapabilitiesKHR *pSurfaceCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDisplayModeKHR(vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::DisplayModeKHR *pMode, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::LayerProperties, LayerPropertiesAllocator > >::type enumerateDeviceLayerProperties(LayerPropertiesAllocator &layerPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, uint32_t *pCounterCount, vk::PerformanceCounterKHR *pCounters, vk::PerformanceCounterDescriptionKHR *pCounterDescriptions, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getFormatProperties2(vk::Format format, vk::FormatProperties2 *pFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getQueueFamilyPerformanceQueryPassesKHR(const vk::QueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ExtensionProperties, ExtensionPropertiesAllocator > >::type enumerateDeviceExtensionProperties(Optional< const std::string > layerName, ExtensionPropertiesAllocator &extensionPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageFormatProperties >::type getImageFormatProperties(vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DisplayModeKHR, Dispatch > >::type createDisplayModeKHRUnique(vk::DisplayKHR display, const vk::DisplayModeCreateInfoKHR &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getVideoEncodeQualityLevelPropertiesKHR(const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR *pQualityLevelInfo, vk::VideoEncodeQualityLevelPropertiesKHR *pQualityLevelProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator > getSparseImageFormatProperties2KHR(const vk::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getMemoryProperties2KHR(vk::PhysicalDeviceMemoryProperties2 *pMemoryProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getMultisamplePropertiesEXT(vk::SampleCountFlagBits samples, vk::MultisamplePropertiesEXT *pMultisampleProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR(uint32_t *pPropertyCount, vk::DisplayPropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator > >::type getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, SurfaceFormat2KHRAllocator &surfaceFormat2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(vk::DisplayModeKHR mode, uint32_t planeIndex, vk::DisplayPlaneCapabilitiesKHR *pCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::ExternalFenceProperties getExternalFenceProperties(const vk::PhysicalDeviceExternalFenceInfo &externalFenceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(uint32_t *pPropertyCount, vk::CooperativeMatrixPropertiesNV *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator > >::type getVideoFormatPropertiesKHR(const vk::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator > >::type getDisplayModePropertiesKHR(vk::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getFeatures2KHR(vk::PhysicalDeviceFeatures2 *pFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::ExternalBufferProperties getExternalBufferPropertiesKHR(const vk::PhysicalDeviceExternalBufferInfo &externalBufferInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< StructureChain, StructureChainAllocator > getQueueFamilyProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator!=(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14043
bool operator==(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14038
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayProperties2KHR, DisplayProperties2KHRAllocator > >::type getDisplayProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR(const vk::VideoProfileInfoKHR *pVideoProfile, vk::VideoCapabilitiesKHR *pCapabilities, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDrmDisplayEXT(int32_t drmFd, uint32_t connectorId, vk::DisplayKHR *display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< vk::PerformanceCounterKHR, PerformanceCounterKHRAllocator >, std::vector< vk::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator > > >::type enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator > >::type getCooperativeMatrixPropertiesKHR(CooperativeMatrixPropertiesKHRAllocator &cooperativeMatrixPropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceCapabilitiesKHR >::type getSurfaceCapabilitiesKHR(vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties2, SparseImageFormatProperties2Allocator > getSparseImageFormatProperties2KHR(const vk::PhysicalDeviceSparseImageFormatInfo2 &formatInfo, SparseImageFormatProperties2Allocator &sparseImageFormatProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getExternalSemaphorePropertiesKHR(const vk::PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, vk::ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::SurfaceCapabilities2KHR >::type getSurfaceCapabilities2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getSparseImageFormatProperties2KHR(const vk::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, vk::SparseImageFormatProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::ExternalSemaphoreProperties getExternalSemaphoreProperties(const vk::PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator > >::type getDisplayModeProperties2KHR(vk::DisplayKHR display, DisplayModeProperties2KHRAllocator &displayModeProperties2KHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getFeatures2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
ResultValueType< void >::type acquireDrmDisplayEXT(int32_t drmFd, vk::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getMemoryProperties2(vk::PhysicalDeviceMemoryProperties2 *pMemoryProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator > >::type getSupportedFramebufferMixedSamplesCombinationsNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR(uint32_t *pPropertyCount, vk::CooperativeMatrixPropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getSparseImageFormatProperties2(const vk::PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, vk::SparseImageFormatProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(vk::SurfaceKHR surface, uint32_t *pPresentModeCount, vk::PresentModeKHR *pPresentModes, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TimeDomainKHR, TimeDomainKHRAllocator > >::type getCalibrateableTimeDomainsEXT(TimeDomainKHRAllocator &timeDomainKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator > >::type getToolProperties(PhysicalDeviceToolPropertiesAllocator &physicalDeviceToolPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::MultisamplePropertiesEXT getMultisamplePropertiesEXT(vk::SampleCountFlagBits samples, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getFormatProperties2(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR(const vk::PhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, vk::VideoFormatPropertiesKHR *pVideoFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::TimeDomainKHR, TimeDomainKHRAllocator > >::type getCalibrateableTimeDomainsEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::DisplayKHR, Dispatch > >::type getDrmDisplayEXTUnique(int32_t drmFd, uint32_t connectorId, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties(uint32_t *pPropertyCount, vk::LayerProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator > >::type getDisplayPlaneProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::LayerProperties, LayerPropertiesAllocator > >::type enumerateDeviceLayerProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< StructureChain, StructureChainAllocator > >::type getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, StructureChainAllocator &structureChainAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(vk::DisplayKHR display, uint32_t *pPropertyCount, vk::DisplayModePropertiesKHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageFormatProperties(vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ImageFormatProperties *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator > >::type getDisplayModePropertiesKHR(vk::DisplayKHR display, DisplayModePropertiesKHRAllocator &displayModePropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayPropertiesKHR, DisplayPropertiesKHRAllocator > >::type getDisplayPropertiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getToolPropertiesEXT(uint32_t *pToolCount, vk::PhysicalDeviceToolProperties *pToolProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator > >::type getDisplayModeProperties2KHR(vk::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator > >::type getOpticalFlowImageFormatsNV(const vk::OpticalFlowImageFormatInfoNV &opticalFlowImageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::SurfaceFormat2KHR, SurfaceFormat2KHRAllocator > >::type getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getFeatures2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getImageFormatProperties2(const vk::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getSurfaceCapabilities2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::FormatProperties2 getFormatProperties2(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< StructureChain, StructureChainAllocator > getQueueFamilyProperties2KHR(StructureChainAllocator &structureChainAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, vk::ExtensionProperties *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getToolProperties(uint32_t *pToolCount, vk::PhysicalDeviceToolProperties *pToolProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getQueueFamilyProperties2KHR(uint32_t *pQueueFamilyPropertyCount, vk::QueueFamilyProperties2 *pQueueFamilyProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getMemoryProperties(vk::PhysicalDeviceMemoryProperties *pMemoryProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator > >::type getToolPropertiesEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(uint32_t *pPropertyCount, vk::DisplayPlaneProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
bool operator<(PhysicalDevice const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14048
VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR(uint32_t *pPropertyCount, vk::DisplayProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getFeatures2(vk::PhysicalDeviceFeatures2 *pFeatures, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< StructureChain, StructureChainAllocator > >::type getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties, QueueFamilyPropertiesAllocator > getQueueFamilyProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::PhysicalDeviceFeatures getFeatures(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result createDevice(const vk::DeviceCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Device *pDevice, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::Device >::type createDevice(const vk::DeviceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR(uint32_t queueFamilyIndex, vk::SurfaceKHR surface, vk::Bool32 *pSupported, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
PhysicalDevice & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:14029
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties2, QueueFamilyProperties2Allocator > getQueueFamilyProperties2(QueueFamilyProperties2Allocator &queueFamilyProperties2Allocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties2, QueueFamilyProperties2Allocator > getQueueFamilyProperties2KHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT(uint32_t *pTimeDomainCount, vk::TimeDomainKHR *pTimeDomains, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties2, QueueFamilyProperties2Allocator > getQueueFamilyProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::SparseImageFormatProperties, SparseImageFormatPropertiesAllocator > getSparseImageFormatProperties(vk::Format format, vk::ImageType type, vk::SampleCountFlagBits samples, vk::ImageUsageFlags usage, vk::ImageTiling tiling, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType, vk::ExternalImageFormatPropertiesNV *pExternalImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR(vk::SurfaceKHR surface, uint32_t *pRectCount, vk::Rect2D *pRects, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(uint32_t *pCombinationCount, vk::FramebufferMixedSamplesCombinationNV *pCombinations, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayKHR, DisplayKHRAllocator > >::type getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::StructureChain< X, Y, Z... > >::type getVideoCapabilitiesKHR(const vk::VideoProfileInfoKHR &videoProfile, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator > >::type getVideoFormatPropertiesKHR(const vk::PhysicalDeviceVideoFormatInfoKHR &videoFormatInfo, VideoFormatPropertiesKHRAllocator &videoFormatPropertiesKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getExternalBufferPropertiesKHR(const vk::PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, vk::ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::ExternalImageFormatPropertiesNV >::type getExternalImageFormatPropertiesNV(vk::Format format, vk::ImageType type, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, vk::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageFormatProperties2 >::type getImageFormatProperties2KHR(const vk::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void releaseDisplayEXT(vk::DisplayKHR display, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::QueueFamilyProperties, QueueFamilyPropertiesAllocator > getQueueFamilyProperties(QueueFamilyPropertiesAllocator &queueFamilyPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::pair< std::vector< vk::PerformanceCounterKHR, PerformanceCounterKHRAllocator >, std::vector< vk::PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator > > >::type enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex, PerformanceCounterKHRAllocator &performanceCounterKHRAllocator, PerformanceCounterDescriptionKHRAllocator &performanceCounterDescriptionKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PhysicalDeviceToolProperties, PhysicalDeviceToolPropertiesAllocator > >::type getToolProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void getExternalFenceProperties(const vk::PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, vk::ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getImageFormatProperties2(const vk::PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, vk::ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR(vk::DisplayKHR display, uint32_t *pPropertyCount, vk::DisplayModeProperties2KHR *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::ImageFormatProperties2 >::type getImageFormatProperties2(const vk::PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getMemoryProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::PhysicalDeviceProperties getProperties(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR(uint32_t *pFragmentShadingRateCount, vk::PhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD vk::FormatProperties getFormatProperties(vk::Format format, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< vk::Bool32 >::type getSurfaceSupportKHR(uint32_t queueFamilyIndex, vk::SurfaceKHR surface, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::CooperativeMatrixPropertiesKHR, CooperativeMatrixPropertiesKHRAllocator > >::type getCooperativeMatrixPropertiesKHR(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::DisplayKHR, DisplayKHRAllocator > >::type getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, DisplayKHRAllocator &displayKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< vk::DisplayPlaneCapabilitiesKHR >::type getDisplayPlaneCapabilitiesKHR(vk::DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getProperties2(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getProperties2KHR(vk::PhysicalDeviceProperties2 *pProperties, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(const vk::QueryPoolPerformanceCreateInfoKHR &performanceQueryCreateInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::OpticalFlowImageFormatPropertiesNV, OpticalFlowImageFormatPropertiesNVAllocator > >::type getOpticalFlowImageFormatsNV(const vk::OpticalFlowImageFormatInfoNV &opticalFlowImageFormatInfo, OpticalFlowImageFormatPropertiesNVAllocator &opticalFlowImageFormatPropertiesNVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::PresentModeKHR, PresentModeKHRAllocator > >::type getSurfacePresentModesKHR(vk::SurfaceKHR surface, PresentModeKHRAllocator &presentModeKHRAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, vk::SurfaceFormat2KHR *pSurfaceFormats, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7141
VkPipelineCache CType
Definition: vulkan_handles.hpp:7143
PipelineCache & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7165
VkPipelineCache NativeType
Definition: vulkan_handles.hpp:7144
bool operator==(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7174
bool operator!=(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7179
bool operator<(PipelineCache const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7184
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache(VkPipelineCache pipelineCache) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7155
VULKAN_HPP_CONSTEXPR PipelineCache()=default
VULKAN_HPP_CONSTEXPR PipelineCache(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7153
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7200
Definition: vulkan_handles.hpp:3222
VULKAN_HPP_CONSTEXPR PipelineLayout(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3234
bool operator!=(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3260
VkPipelineLayout NativeType
Definition: vulkan_handles.hpp:3225
PipelineLayout & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3246
bool operator<(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3265
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout(VkPipelineLayout pipelineLayout) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3236
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3281
VULKAN_HPP_CONSTEXPR PipelineLayout()=default
bool operator==(PipelineLayout const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3255
VkPipelineLayout CType
Definition: vulkan_handles.hpp:3224
Definition: vulkan_handles.hpp:3483
bool operator<(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3526
VkPipeline NativeType
Definition: vulkan_handles.hpp:3486
VkPipeline CType
Definition: vulkan_handles.hpp:3485
VULKAN_HPP_CONSTEXPR Pipeline(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3495
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3542
bool operator!=(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3521
VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline(VkPipeline pipeline) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3497
bool operator==(Pipeline const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3516
VULKAN_HPP_CONSTEXPR Pipeline()=default
Pipeline & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3507
Definition: vulkan.hpp:6075
Definition: vulkan_handles.hpp:7928
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7987
VkPrivateDataSlot NativeType
Definition: vulkan_handles.hpp:7931
bool operator!=(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7966
VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot(VkPrivateDataSlot privateDataSlot) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7942
PrivateDataSlot & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7952
VULKAN_HPP_CONSTEXPR PrivateDataSlot()=default
bool operator==(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7961
VULKAN_HPP_CONSTEXPR PrivateDataSlot(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7940
bool operator<(PrivateDataSlot const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:7971
VkPrivateDataSlot CType
Definition: vulkan_handles.hpp:7930
Definition: vulkan_handles.hpp:3048
VULKAN_HPP_CONSTEXPR QueryPool(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3060
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3107
VULKAN_HPP_CONSTEXPR QueryPool()=default
bool operator<(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3091
QueryPool & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3072
VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool(VkQueryPool queryPool) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3062
VkQueryPool NativeType
Definition: vulkan_handles.hpp:3051
VkQueryPool CType
Definition: vulkan_handles.hpp:3050
bool operator==(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3081
bool operator!=(QueryPool const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3086
Definition: vulkan_handles.hpp:8537
VULKAN_HPP_NODISCARD Result bindSparse(uint32_t bindInfoCount, const vk::BindSparseInfo *pBindInfo, vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type setPerformanceConfigurationINTEL(vk::PerformanceConfigurationINTEL configuration, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
Queue & operator=(VkQueue queue) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8553
VkQueue NativeType
Definition: vulkan_handles.hpp:8540
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type bindSparse(vk::ArrayProxy< const vk::BindSparseInfo > const &bindInfo, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD std::vector< vk::CheckpointData2NV, CheckpointData2NVAllocator > getCheckpointData2NV(CheckpointData2NVAllocator &checkpointData2NVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void beginDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void getCheckpointData2NV(uint32_t *pCheckpointDataCount, vk::CheckpointData2NV *pCheckpointData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void notifyOutOfBandNV(const vk::OutOfBandQueueTypeInfoNV &queueTypeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::CheckpointDataNV, CheckpointDataNVAllocator > getCheckpointDataNV(CheckpointDataNVAllocator &checkpointDataNVAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void insertDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Queue()=default
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type submit2(vk::ArrayProxy< const vk::SubmitInfo2 > const &submits, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD vk::Result presentKHR(const vk::PresentInfoKHR &presentInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void insertDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT &labelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VkQueue CType
Definition: vulkan_handles.hpp:8539
bool operator!=(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8573
VULKAN_HPP_NODISCARD Result presentKHR(const vk::PresentInfoKHR *pPresentInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type submit2KHR(vk::ArrayProxy< const vk::SubmitInfo2 > const &submits, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
bool operator<(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8578
void getCheckpointDataNV(uint32_t *pCheckpointDataCount, vk::CheckpointDataNV *pCheckpointData, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD std::vector< vk::CheckpointDataNV, CheckpointDataNVAllocator > getCheckpointDataNV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
void notifyOutOfBandNV(const vk::OutOfBandQueueTypeInfoNV *pQueueTypeInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR Queue(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8549
VULKAN_HPP_NODISCARD std::vector< vk::CheckpointData2NV, CheckpointData2NVAllocator > getCheckpointData2NV(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD Result submit(uint32_t submitCount, const vk::SubmitInfo *pSubmits, vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD Result submit2(uint32_t submitCount, const vk::SubmitInfo2 *pSubmits, vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Queue & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8559
void beginDebugUtilsLabelEXT(const vk::DebugUtilsLabelEXT &labelInfo, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
Queue(VkQueue queue) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8551
bool operator==(Queue const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8568
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8754
VULKAN_HPP_NODISCARD Result submit2KHR(uint32_t submitCount, const vk::SubmitInfo2 *pSubmits, vk::Fence fence, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
void endDebugUtilsLabelEXT(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type waitIdle(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS ResultValueType< void >::type submit(vk::ArrayProxy< const vk::SubmitInfo > const &submits, vk::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) const
Definition: vulkan_handles.hpp:8011
VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass(VkRenderPass renderPass) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8025
VkRenderPass NativeType
Definition: vulkan_handles.hpp:8014
VkRenderPass CType
Definition: vulkan_handles.hpp:8013
VULKAN_HPP_CONSTEXPR RenderPass(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8023
bool operator<(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8054
RenderPass & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8035
bool operator==(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8044
VULKAN_HPP_CONSTEXPR RenderPass()=default
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8070
bool operator!=(RenderPass const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8049
Definition: vulkan_handles.hpp:8185
bool operator==(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8221
VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8199
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8197
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()=default
VkSamplerYcbcrConversion NativeType
Definition: vulkan_handles.hpp:8188
bool operator<(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8231
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8247
SamplerYcbcrConversion & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8212
VkSamplerYcbcrConversion CType
Definition: vulkan_handles.hpp:8187
bool operator!=(SamplerYcbcrConversion const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8226
Definition: vulkan_handles.hpp:8098
VkSampler CType
Definition: vulkan_handles.hpp:8100
Sampler & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8122
VULKAN_HPP_TYPESAFE_EXPLICIT Sampler(VkSampler sampler) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8112
VkSampler NativeType
Definition: vulkan_handles.hpp:8101
bool operator==(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8131
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8157
bool operator<(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8141
VULKAN_HPP_CONSTEXPR Sampler()=default
bool operator!=(Sampler const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8136
VULKAN_HPP_CONSTEXPR Sampler(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8110
Definition: vulkan_handles.hpp:2790
VkSemaphore NativeType
Definition: vulkan_handles.hpp:2793
VkSemaphore CType
Definition: vulkan_handles.hpp:2792
bool operator!=(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2828
bool operator<(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2833
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2849
VULKAN_HPP_CONSTEXPR Semaphore(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2802
VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore(VkSemaphore semaphore) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2804
VULKAN_HPP_CONSTEXPR Semaphore()=default
Semaphore & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2814
bool operator==(Semaphore const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2823
Definition: vulkan_handles.hpp:3570
bool operator<(ShaderEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3613
VULKAN_HPP_CONSTEXPR ShaderEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3582
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3629
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT(VkShaderEXT shaderEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3584
VkShaderEXT CType
Definition: vulkan_handles.hpp:3572
VkShaderEXT NativeType
Definition: vulkan_handles.hpp:3573
VULKAN_HPP_CONSTEXPR ShaderEXT()=default
ShaderEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3594
bool operator!=(ShaderEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3608
bool operator==(ShaderEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:3603
Definition: vulkan_handles.hpp:8277
ShaderModule & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8301
VULKAN_HPP_CONSTEXPR ShaderModule()=default
bool operator==(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8310
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8336
VkShaderModule CType
Definition: vulkan_handles.hpp:8279
bool operator<(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8320
bool operator!=(ShaderModule const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8315
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule(VkShaderModule shaderModule) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8291
VkShaderModule NativeType
Definition: vulkan_handles.hpp:8280
VULKAN_HPP_CONSTEXPR ShaderModule(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8289
Definition: vulkan.hpp:654
Definition: vulkan_handles.hpp:2355
bool operator!=(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2393
VkSurfaceKHR NativeType
Definition: vulkan_handles.hpp:2358
VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR(VkSurfaceKHR surfaceKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2369
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2414
SurfaceKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2379
VULKAN_HPP_CONSTEXPR SurfaceKHR()=default
bool operator<(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2398
bool operator==(SurfaceKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2388
VULKAN_HPP_CONSTEXPR SurfaceKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2367
VkSurfaceKHR CType
Definition: vulkan_handles.hpp:2357
Definition: vulkan_handles.hpp:2703
VULKAN_HPP_CONSTEXPR SwapchainKHR()=default
SwapchainKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2727
VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR(VkSwapchainKHR swapchainKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2717
VkSwapchainKHR NativeType
Definition: vulkan_handles.hpp:2706
bool operator==(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2736
VkSwapchainKHR CType
Definition: vulkan_handles.hpp:2705
VULKAN_HPP_CONSTEXPR SwapchainKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2715
bool operator!=(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2741
bool operator<(SwapchainKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2746
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:2762
Definition: vulkan.hpp:873
Definition: vulkan.hpp:877
Definition: vulkan_handles.hpp:8364
ValidationCacheEXT & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8390
VkValidationCacheEXT CType
Definition: vulkan_handles.hpp:8366
VULKAN_HPP_CONSTEXPR ValidationCacheEXT()=default
VULKAN_HPP_CONSTEXPR ValidationCacheEXT(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8376
bool operator==(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8399
VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8378
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8425
bool operator<(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8409
VkValidationCacheEXT NativeType
Definition: vulkan_handles.hpp:8367
bool operator!=(ValidationCacheEXT const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8404
Definition: vulkan_handles.hpp:6710
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6769
bool operator==(VideoSessionKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6743
bool operator!=(VideoSessionKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6748
VULKAN_HPP_CONSTEXPR VideoSessionKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6722
VULKAN_HPP_CONSTEXPR VideoSessionKHR()=default
VideoSessionKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6734
bool operator<(VideoSessionKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6753
VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR(VkVideoSessionKHR videoSessionKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:6724
VkVideoSessionKHR CType
Definition: vulkan_handles.hpp:6712
VkVideoSessionKHR NativeType
Definition: vulkan_handles.hpp:6713
Definition: vulkan_handles.hpp:8453
bool operator<(VideoSessionParametersKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8499
VkVideoSessionParametersKHR NativeType
Definition: vulkan_handles.hpp:8456
bool operator!=(VideoSessionParametersKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8494
VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8465
VkVideoSessionParametersKHR CType
Definition: vulkan_handles.hpp:8455
bool operator==(VideoSessionParametersKHR const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8489
VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR()=default
VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8467
VideoSessionParametersKHR & operator=(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8480
bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_handles.hpp:8515
SampleCountFlagBits
Definition: vulkan_enums.hpp:2057
FrontFace
Definition: vulkan_enums.hpp:2803
Flags< CommandBufferResetFlagBits > CommandBufferResetFlags
Definition: vulkan_enums.hpp:3496
SurfaceCounterFlagBitsEXT
Definition: vulkan_enums.hpp:5272
uint32_t SampleMask
Definition: vulkan.hpp:6124
ImageTiling
Definition: vulkan_enums.hpp:1909
Flags< CullModeFlagBits > CullModeFlags
Definition: vulkan_enums.hpp:2701
PrimitiveTopology
Definition: vulkan_enums.hpp:2923
Flags< DebugUtilsMessageTypeFlagBitsEXT > DebugUtilsMessageTypeFlagsEXT
Definition: vulkan_enums.hpp:5518
QueryType
Definition: vulkan_enums.hpp:2343
AccelerationStructureBuildTypeKHR
Definition: vulkan_enums.hpp:5590
Flags< ImageCreateFlagBits > ImageCreateFlags
Definition: vulkan_enums.hpp:1892
VULKAN_HPP_NODISCARD ResultValueType< uint32_t >::type enumerateInstanceVersion(Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)
OpticalFlowSessionBindingPointNV
Definition: vulkan_enums.hpp:6851
uint64_t DeviceAddress
Definition: vulkan.hpp:6121
Flags< ImageUsageFlagBits > ImageUsageFlags
Definition: vulkan_enums.hpp:1948
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::ExtensionProperties, ExtensionPropertiesAllocator > >::type enumerateInstanceExtensionProperties(Optional< const std::string > layerName, ExtensionPropertiesAllocator &extensionPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)
Flags< ColorComponentFlagBits > ColorComponentFlags
Definition: vulkan_enums.hpp:2671
VULKAN_HPP_NODISCARD ResultValueType< std::vector< vk::LayerProperties, LayerPropertiesAllocator > >::type enumerateInstanceLayerProperties(LayerPropertiesAllocator &layerPropertiesAllocator, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)
Flags< ImageAspectFlagBits > ImageAspectFlags
Definition: vulkan_enums.hpp:2202
PipelineBindPoint
Definition: vulkan_enums.hpp:3401
ImageLayout
Definition: vulkan_enums.hpp:2477
Flags< CommandPoolResetFlagBits > CommandPoolResetFlags
Definition: vulkan_enums.hpp:3476
DiscardRectangleModeEXT
Definition: vulkan_enums.hpp:5334
DescriptorType
Definition: vulkan_enums.hpp:3244
Flags< MemoryMapFlagBits > MemoryMapFlags
Definition: vulkan_enums.hpp:2173
VULKAN_HPP_INLINE vk::DebugReportObjectTypeEXT debugReportObjectType(vk::ObjectType objectType)
Definition: vulkan_enums.hpp:7208
Flags< QueryControlFlagBits > QueryControlFlags
Definition: vulkan_enums.hpp:3527
Flags< ExternalMemoryHandleTypeFlagBitsNV > ExternalMemoryHandleTypeFlagsNV
Definition: vulkan_enums.hpp:5182
CoverageModulationModeNV
Definition: vulkan_enums.hpp:5745
PerformanceParameterTypeINTEL
Definition: vulkan_enums.hpp:5874
Flags< PipelineStageFlagBits2 > PipelineStageFlags2
Definition: vulkan_enums.hpp:4134
ProvokingVertexModeEXT
Definition: vulkan_enums.hpp:5995
TimeDomainKHR
Definition: vulkan_enums.hpp:7151
LineRasterizationModeEXT
Definition: vulkan_enums.hpp:6030
DebugReportObjectTypeEXT
Definition: vulkan_enums.hpp:4618
AccelerationStructureCompatibilityKHR
Definition: vulkan_enums.hpp:5695
Flags< DependencyFlagBits > DependencyFlags
Definition: vulkan_enums.hpp:3375
Flags< ShaderStageFlagBits > ShaderStageFlags
Definition: vulkan_enums.hpp:2967
FragmentShadingRateCombinerOpKHR
Definition: vulkan_enums.hpp:5925
Flags< DebugReportFlagBitsEXT > DebugReportFlagsEXT
Definition: vulkan_enums.hpp:4606
ShaderStageFlagBits
Definition: vulkan_enums.hpp:2938
CoarseSampleOrderTypeNV
Definition: vulkan_enums.hpp:5804
DebugUtilsMessageSeverityFlagBitsEXT
Definition: vulkan_enums.hpp:5492
Flags< PeerMemoryFeatureFlagBits > PeerMemoryFeatureFlags
Definition: vulkan_enums.hpp:3606
TessellationDomainOrigin
Definition: vulkan_enums.hpp:3658
CopyAccelerationStructureModeKHR
Definition: vulkan_enums.hpp:5678
ExternalMemoryHandleTypeFlagBits
Definition: vulkan_enums.hpp:3710
PipelineStageFlagBits
Definition: vulkan_enums.hpp:2115
uint32_t Bool32
Definition: vulkan.hpp:6120
Flags< QueryResultFlagBits > QueryResultFlags
Definition: vulkan_enums.hpp:2331
Filter
Definition: vulkan_enums.hpp:3152
ImageType
Definition: vulkan_enums.hpp:1916
LogicOp
Definition: vulkan_enums.hpp:2809
ConservativeRasterizationModeEXT
Definition: vulkan_enums.hpp:5355
Flags< PipelineStageFlagBits > PipelineStageFlags
Definition: vulkan_enums.hpp:2151
SubpassContents
Definition: vulkan_enums.hpp:3564
PolygonMode
Definition: vulkan_enums.hpp:2915
uint64_t DeviceSize
Definition: vulkan.hpp:6122
Result
Definition: vulkan_enums.hpp:231
FragmentShadingRateNV
Definition: vulkan_enums.hpp:6395
CoverageReductionModeNV
Definition: vulkan_enums.hpp:5974
MemoryRequirements2 MemoryRequirements2KHR
Definition: vulkan_handles.hpp:167
VULKAN_HPP_NODISCARD ResultValueType< UniqueHandle< vk::Instance, Dispatch > >::type createInstanceUnique(const vk::InstanceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)
VULKAN_HPP_NODISCARD ResultValueType< vk::Instance >::type createInstance(const vk::InstanceCreateInfo &createInfo, Optional< const vk::AllocationCallbacks > allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)
CompareOp
Definition: vulkan_enums.hpp:2682
bool operator<(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:210
PresentModeKHR
Definition: vulkan_enums.hpp:4374
IndexType
Definition: vulkan_enums.hpp:3537
PipelineInfoKHR PipelineInfoEXT
Definition: vulkan_handles.hpp:1143
Flags< DeviceGroupPresentModeFlagBitsKHR > DeviceGroupPresentModeFlagsKHR
Definition: vulkan_enums.hpp:4452
Flags< CommandPoolTrimFlagBits > CommandPoolTrimFlags
Definition: vulkan_enums.hpp:3640
ObjectType
Definition: vulkan_enums.hpp:1412
Format
Definition: vulkan_enums.hpp:1485
Flags< StencilFaceFlagBits > StencilFaceFlags
Definition: vulkan_enums.hpp:3553
void * RemoteAddressNV
Definition: vulkan.hpp:6123
Flags< DescriptorPoolResetFlagBits > DescriptorPoolResetFlags
Definition: vulkan_enums.hpp:3270
ShaderInfoTypeAMD
Definition: vulkan_enums.hpp:5149
ShaderGroupShaderKHR
Definition: vulkan_enums.hpp:5735
StencilOp
Definition: vulkan_enums.hpp:2982
Definition: vulkan_structs.hpp:21
Definition: vulkan_structs.hpp:723
Definition: vulkan_structs.hpp:949
Definition: vulkan_structs.hpp:1055
Definition: vulkan_structs.hpp:1292
Definition: vulkan_structs.hpp:2150
Definition: vulkan_structs.hpp:2259
Definition: vulkan_structs.hpp:329
Definition: vulkan_structs.hpp:421
Definition: vulkan_structs.hpp:577
Definition: vulkan_structs.hpp:182
Definition: vulkan_structs.hpp:1984
Definition: vulkan_structs.hpp:2513
Definition: vulkan_structs.hpp:2646
Definition: vulkan_structs.hpp:2791
Definition: vulkan_structs.hpp:2904
Definition: vulkan_structs.hpp:3450
Definition: vulkan_structs.hpp:3241
Definition: vulkan_structs.hpp:3961
Definition: vulkan_structs.hpp:4171
Definition: vulkan_structs.hpp:4267
Definition: vulkan_structs.hpp:4407
Definition: vulkan_structs.hpp:4637
Definition: vulkan_structs.hpp:5792
Definition: vulkan_structs.hpp:5975
Definition: vulkan_structs.hpp:6174
Definition: vulkan_structs.hpp:6296
Definition: vulkan_structs.hpp:6395
Definition: vulkan_structs.hpp:6868
Definition: vulkan_structs.hpp:7112
Definition: vulkan_structs.hpp:7279
Definition: vulkan_structs.hpp:7404
Definition: vulkan_structs.hpp:7525
Definition: vulkan_structs.hpp:7645
Definition: vulkan_structs.hpp:8010
Definition: vulkan_structs.hpp:8176
Definition: vulkan_structs.hpp:8296
Definition: vulkan_structs.hpp:8402
Definition: vulkan_structs.hpp:8501
Definition: vulkan_structs.hpp:8598
Definition: vulkan_structs.hpp:8693
Definition: vulkan_structs.hpp:8771
Definition: vulkan_structs.hpp:9985
Definition: vulkan_structs.hpp:10081
Definition: vulkan_structs.hpp:10211
Definition: vulkan_structs.hpp:10543
Definition: vulkan_structs.hpp:10732
Definition: vulkan_structs.hpp:12009
Definition: vulkan_structs.hpp:12127
Definition: vulkan_structs.hpp:12224
Definition: vulkan_structs.hpp:12449
Definition: vulkan_structs.hpp:12759
Definition: vulkan_structs.hpp:12942
Definition: vulkan_structs.hpp:13040
Definition: vulkan_structs.hpp:13138
Definition: vulkan_structs.hpp:13375
Definition: vulkan_structs.hpp:13474
Definition: vulkan_structs.hpp:13556
Definition: vulkan_structs.hpp:13996
Definition: vulkan_structs.hpp:14090
Definition: vulkan_structs.hpp:14223
Definition: vulkan_structs.hpp:14342
Definition: vulkan_structs.hpp:15067
Definition: vulkan_structs.hpp:15384
Definition: vulkan_structs.hpp:15507
Definition: vulkan_structs.hpp:16245
Definition: vulkan_structs.hpp:16366
Definition: vulkan_structs.hpp:16485
Definition: vulkan_structs.hpp:16586
Definition: vulkan_structs.hpp:16768
Definition: vulkan_structs.hpp:16938
Definition: vulkan_structs.hpp:17058
Definition: vulkan_structs.hpp:17161
Definition: vulkan_structs.hpp:17309
Definition: vulkan_structs.hpp:17477
Definition: vulkan_structs.hpp:17872
Definition: vulkan_structs.hpp:18048
Definition: vulkan_structs.hpp:18216
Definition: vulkan_structs.hpp:18559
Definition: vulkan_structs.hpp:18725
Definition: vulkan_structs.hpp:18821
Definition: vulkan_structs.hpp:18925
Definition: vulkan_structs.hpp:19207
Definition: vulkan_structs.hpp:19373
Definition: vulkan_structs.hpp:19474
Definition: vulkan_structs.hpp:19592
Definition: vulkan_enums.hpp:221
Definition: vulkan_structs.hpp:19693
Definition: vulkan_structs.hpp:19807
Definition: vulkan_structs.hpp:20064
Definition: vulkan_structs.hpp:20187
Definition: vulkan_structs.hpp:20303
Definition: vulkan_structs.hpp:20562
Definition: vulkan_structs.hpp:20851
Definition: vulkan_structs.hpp:20966
Definition: vulkan_structs.hpp:21098
Definition: vulkan_structs.hpp:21261
Definition: vulkan_structs.hpp:21376
Definition: vulkan_structs.hpp:21616
Definition: vulkan_structs.hpp:21895
Definition: vulkan_structs.hpp:21488
Definition: vulkan_structs.hpp:22033
Definition: vulkan_structs.hpp:22200
Definition: vulkan_structs.hpp:22320
Definition: vulkan_structs.hpp:22418
Definition: vulkan_structs.hpp:22516
Definition: vulkan_structs.hpp:23071
Definition: vulkan_structs.hpp:23290
Definition: vulkan_structs.hpp:23403
Definition: vulkan_structs.hpp:23515
Definition: vulkan_structs.hpp:23634
Definition: vulkan_structs.hpp:24155
Definition: vulkan_structs.hpp:24480
Definition: vulkan_structs.hpp:24719
Definition: vulkan_structs.hpp:24969
Definition: vulkan_structs.hpp:25237
Definition: vulkan_structs.hpp:25342
Definition: vulkan_structs.hpp:25426
Definition: vulkan_structs.hpp:25554
Definition: vulkan_structs.hpp:25767
Definition: vulkan_structs.hpp:25641
Definition: vulkan_structs.hpp:25982
Definition: vulkan_structs.hpp:26114
Definition: vulkan_structs.hpp:27341
Definition: vulkan_structs.hpp:27458
Definition: vulkan_structs.hpp:27555
Definition: vulkan_structs.hpp:27649
Definition: vulkan_structs.hpp:27746
Definition: vulkan_structs.hpp:27958
Definition: vulkan_structs.hpp:28085
Definition: vulkan_structs.hpp:27862
Definition: vulkan_structs.hpp:28279
Definition: vulkan_structs.hpp:28387
Definition: vulkan_structs.hpp:28485
Definition: vulkan_structs.hpp:28613
Definition: vulkan_structs.hpp:28702
Definition: vulkan_structs.hpp:28841
Definition: vulkan_structs.hpp:28983
Definition: vulkan_structs.hpp:29190
Definition: vulkan_structs.hpp:29562
Definition: vulkan_structs.hpp:29772
Definition: vulkan_structs.hpp:29882
Definition: vulkan_structs.hpp:29981
Definition: vulkan_structs.hpp:30080
Definition: vulkan_structs.hpp:30236
Definition: vulkan_structs.hpp:30334
Definition: vulkan_structs.hpp:30435
Definition: vulkan_structs.hpp:30552
Definition: vulkan_structs.hpp:30648
Definition: vulkan_structs.hpp:30754
Definition: vulkan_structs.hpp:31012
Definition: vulkan_structs.hpp:31092
Definition: vulkan_structs.hpp:31274
Definition: vulkan_structs.hpp:31457
Definition: vulkan_structs.hpp:31371
Definition: vulkan_structs.hpp:31639
Definition: vulkan_structs.hpp:31566
Definition: vulkan_structs.hpp:31722
Definition: vulkan_structs.hpp:31909
Definition: vulkan_structs.hpp:31805
Definition: vulkan_structs.hpp:31992
Definition: vulkan_structs.hpp:32170
Definition: vulkan_structs.hpp:32097
Definition: vulkan_structs.hpp:32253
Definition: vulkan_structs.hpp:32349
Definition: vulkan_structs.hpp:32580
Definition: vulkan_structs.hpp:32468
Definition: vulkan_structs.hpp:32663
Definition: vulkan_structs.hpp:33055
Definition: vulkan_structs.hpp:33150
Definition: vulkan_structs.hpp:33236
Definition: vulkan_structs.hpp:33313
Definition: vulkan_structs.hpp:33390
Definition: vulkan_structs.hpp:33488
Definition: vulkan_structs.hpp:33804
Definition: vulkan_structs.hpp:34001
Definition: vulkan_structs.hpp:34098
Definition: vulkan_structs.hpp:34413
Definition: vulkan_structs.hpp:34314
Definition: vulkan_structs.hpp:35608
Definition: vulkan_structs.hpp:35978
Definition: vulkan_structs.hpp:36063
Definition: vulkan_structs.hpp:36524
Definition: vulkan_structs.hpp:36352
Definition: vulkan_structs.hpp:36608
Definition: vulkan_structs.hpp:36706
Definition: vulkan_structs.hpp:36906
Definition: vulkan_structs.hpp:36806
Definition: vulkan_structs.hpp:35897
Definition: vulkan_structs.hpp:37004
Definition: vulkan_structs.hpp:37193
Definition: vulkan_structs.hpp:37412
Definition: vulkan_structs.hpp:37574
Definition: vulkan_structs.hpp:37655
Definition: vulkan_structs.hpp:37748
Definition: vulkan_structs.hpp:37860
Definition: vulkan_structs.hpp:38089
Definition: vulkan_structs.hpp:38281
Definition: vulkan_structs.hpp:38607
Definition: vulkan_structs.hpp:38793
Definition: vulkan_structs.hpp:39075
Definition: vulkan_structs.hpp:1657
Definition: vulkan_structs.hpp:1784
Definition: vulkan_structs.hpp:1868
Definition: vulkan_structs.hpp:1444
Definition: vulkan_structs.hpp:39457
Definition: vulkan_structs.hpp:41915
Definition: vulkan_structs.hpp:42169
Definition: vulkan_structs.hpp:42012
Definition: vulkan_structs.hpp:42417
Definition: vulkan_structs.hpp:42595
Definition: vulkan_structs.hpp:42692
Definition: vulkan_structs.hpp:42779
Definition: vulkan_structs.hpp:10414
Definition: vulkan_structs.hpp:43124
Definition: vulkan_structs.hpp:43220
Definition: vulkan_structs.hpp:43363
Definition: vulkan_structs.hpp:17733
Definition: vulkan_structs.hpp:44029
Definition: vulkan_structs.hpp:44174
Definition: vulkan_structs.hpp:44299
Definition: vulkan_structs.hpp:44381
Definition: vulkan_structs.hpp:44507
Definition: vulkan_structs.hpp:22866
Definition: vulkan_structs.hpp:44761
Definition: vulkan_structs.hpp:44979
Definition: vulkan_structs.hpp:45195
Definition: vulkan_structs.hpp:45334
Definition: vulkan_structs.hpp:45432
Definition: vulkan_structs.hpp:29674
Definition: vulkan_structs.hpp:45531
Definition: vulkan_structs.hpp:18407
Definition: vulkan_structs.hpp:45627
Definition: vulkan_structs.hpp:45724
Definition: vulkan_structs.hpp:45811
Definition: vulkan_structs.hpp:46058
Definition: vulkan_structs.hpp:46178
Definition: vulkan_structs.hpp:46274
Definition: vulkan_structs.hpp:46394
Definition: vulkan_structs.hpp:46499
Definition: vulkan_structs.hpp:46695
Definition: vulkan_structs.hpp:47078
Definition: vulkan_structs.hpp:47185
Definition: vulkan_structs.hpp:48148
Definition: vulkan_structs.hpp:48873
Definition: vulkan_structs.hpp:48570
Definition: vulkan_structs.hpp:38706
Definition: vulkan_structs.hpp:49064
Definition: vulkan_structs.hpp:49160
Definition: vulkan_structs.hpp:49475
Definition: vulkan_structs.hpp:49577
Definition: vulkan_structs.hpp:49697
Definition: vulkan_structs.hpp:49793
Definition: vulkan_structs.hpp:39208
Definition: vulkan_structs.hpp:49997
Definition: vulkan_structs.hpp:50147
Definition: vulkan_structs.hpp:50496
Definition: vulkan_structs.hpp:22622
Definition: vulkan_structs.hpp:50813
Definition: vulkan_structs.hpp:50921
Definition: vulkan_structs.hpp:51010
Definition: vulkan_structs.hpp:51191
Definition: vulkan_structs.hpp:51298
Definition: vulkan_structs.hpp:51704
Definition: vulkan_structs.hpp:51786
Definition: vulkan_structs.hpp:51913
Definition: vulkan_structs.hpp:52011
Definition: vulkan_structs.hpp:52180
Definition: vulkan_structs.hpp:19055
Definition: vulkan_structs.hpp:52332
Definition: vulkan_structs.hpp:52717
Definition: vulkan_structs.hpp:52956
Definition: vulkan_structs.hpp:53076
Definition: vulkan_structs.hpp:53226
Definition: vulkan_structs.hpp:3534
Definition: vulkan_structs.hpp:53319
Definition: vulkan_structs.hpp:53415
Definition: vulkan_structs.hpp:53509
Definition: vulkan_structs.hpp:53592
Definition: vulkan_structs.hpp:53674
Definition: vulkan_structs.hpp:53787
Definition: vulkan_structs.hpp:53895
Definition: vulkan_structs.hpp:54131
Definition: vulkan_structs.hpp:54024
Definition: vulkan_structs.hpp:54267
Definition: vulkan_structs.hpp:54365
Definition: vulkan_structs.hpp:54503
Definition: vulkan_structs.hpp:54600
Definition: vulkan_structs.hpp:54683
Definition: vulkan_structs.hpp:54868
Definition: vulkan_structs.hpp:54983
Definition: vulkan_structs.hpp:55080
Definition: vulkan_structs.hpp:55163
Definition: vulkan_structs.hpp:55264
Definition: vulkan_structs.hpp:55362
Definition: vulkan_structs.hpp:55535
Definition: vulkan_structs.hpp:55631
Definition: vulkan_structs.hpp:55751
Definition: vulkan_structs.hpp:55847
Definition: vulkan_structs.hpp:56014
Definition: vulkan_structs.hpp:56084
Definition: vulkan_structs.hpp:56221
Definition: vulkan_structs.hpp:56327
Definition: vulkan_structs.hpp:56452
Definition: vulkan_structs.hpp:56550
Definition: vulkan_structs.hpp:56706
Definition: vulkan_structs.hpp:56835
Definition: vulkan_structs.hpp:56934
Definition: vulkan_structs.hpp:57233
Definition: vulkan_structs.hpp:57332
Definition: vulkan_structs.hpp:57450
Definition: vulkan_structs.hpp:57685
Definition: vulkan_structs.hpp:57559
Definition: vulkan_structs.hpp:57811
Definition: vulkan_structs.hpp:57921
Definition: vulkan_structs.hpp:58122
Definition: vulkan_structs.hpp:58220
Definition: vulkan_structs.hpp:58318
Definition: vulkan_structs.hpp:58428
Definition: vulkan_structs.hpp:58674
Definition: vulkan_structs.hpp:58783
Definition: vulkan_structs.hpp:58892
Definition: vulkan_structs.hpp:58975
Definition: vulkan_structs.hpp:59058
Definition: vulkan_structs.hpp:59155
Definition: vulkan_structs.hpp:59238
Definition: vulkan_structs.hpp:59336
Definition: vulkan_structs.hpp:59435
Definition: vulkan_structs.hpp:59531
Definition: vulkan_structs.hpp:59630
Definition: vulkan_structs.hpp:59730
Definition: vulkan_structs.hpp:59818
Definition: vulkan_structs.hpp:59927
Definition: vulkan_structs.hpp:60111
Definition: vulkan_structs.hpp:60245
Definition: vulkan_structs.hpp:60343
Definition: vulkan_structs.hpp:60441
Definition: vulkan_structs.hpp:60538
Definition: vulkan_structs.hpp:60725
Definition: vulkan_structs.hpp:60861
Definition: vulkan_structs.hpp:61138
Definition: vulkan_structs.hpp:61490
Definition: vulkan_structs.hpp:62037
Definition: vulkan_structs.hpp:62136
Definition: vulkan_structs.hpp:62272
Definition: vulkan_structs.hpp:62370
Definition: vulkan_structs.hpp:62468
Definition: vulkan_structs.hpp:62551
Definition: vulkan_structs.hpp:62651
Definition: vulkan_structs.hpp:62736
Definition: vulkan_structs.hpp:62836
Definition: vulkan_structs.hpp:62943
Definition: vulkan_structs.hpp:63144
Definition: vulkan_structs.hpp:63241
Definition: vulkan_structs.hpp:63366
Definition: vulkan_structs.hpp:63861
Definition: vulkan_structs.hpp:63960
Definition: vulkan_structs.hpp:64059
Definition: vulkan_structs.hpp:64255
Definition: vulkan_structs.hpp:64378
Definition: vulkan_structs.hpp:64682
Definition: vulkan_structs.hpp:64783
Definition: vulkan_structs.hpp:64867
Definition: vulkan_structs.hpp:65067
Definition: vulkan_structs.hpp:65168
Definition: vulkan_structs.hpp:65276
Definition: vulkan_structs.hpp:65374
Definition: vulkan_structs.hpp:65555
Definition: vulkan_structs.hpp:65653
Definition: vulkan_structs.hpp:65753
Definition: vulkan_structs.hpp:65877
Definition: vulkan_structs.hpp:66062
Definition: vulkan_structs.hpp:66157
Definition: vulkan_structs.hpp:66346
Definition: vulkan_structs.hpp:66471
Definition: vulkan_structs.hpp:66596
Definition: vulkan_structs.hpp:66697
Definition: vulkan_structs.hpp:66820
Definition: vulkan_structs.hpp:66907
Definition: vulkan_structs.hpp:67092
Definition: vulkan_structs.hpp:67188
Definition: vulkan_structs.hpp:67288
Definition: vulkan_structs.hpp:67387
Definition: vulkan_structs.hpp:67499
Definition: vulkan_structs.hpp:67596
Definition: vulkan_structs.hpp:67692
Definition: vulkan_structs.hpp:67885
Definition: vulkan_structs.hpp:67983
Definition: vulkan_structs.hpp:68087
Definition: vulkan_structs.hpp:68194
Definition: vulkan_structs.hpp:68395
Definition: vulkan_structs.hpp:68550
Definition: vulkan_structs.hpp:68692
Definition: vulkan_structs.hpp:68790
Definition: vulkan_structs.hpp:68873
Definition: vulkan_structs.hpp:68996
Definition: vulkan_structs.hpp:69095
Definition: vulkan_structs.hpp:69194
Definition: vulkan_structs.hpp:69292
Definition: vulkan_structs.hpp:69391
Definition: vulkan_structs.hpp:69487
Definition: vulkan_structs.hpp:69587
Definition: vulkan_structs.hpp:69684
Definition: vulkan_structs.hpp:69783
Definition: vulkan_structs.hpp:69894
Definition: vulkan_structs.hpp:70007
Definition: vulkan_structs.hpp:70104
Definition: vulkan_structs.hpp:70188
Definition: vulkan_structs.hpp:70941
Definition: vulkan_structs.hpp:71096
Definition: vulkan_structs.hpp:71178
Definition: vulkan_structs.hpp:71277
Definition: vulkan_structs.hpp:71366
Definition: vulkan_structs.hpp:71464
Definition: vulkan_structs.hpp:71549
Definition: vulkan_structs.hpp:71645
Definition: vulkan_structs.hpp:71762
Definition: vulkan_structs.hpp:71858
Definition: vulkan_structs.hpp:71953
Definition: vulkan_structs.hpp:72042
Definition: vulkan_structs.hpp:72140
Definition: vulkan_structs.hpp:72228
Definition: vulkan_structs.hpp:72409
Definition: vulkan_structs.hpp:72494
Definition: vulkan_structs.hpp:72637
Definition: vulkan_structs.hpp:72743
Definition: vulkan_structs.hpp:72981
Definition: vulkan_structs.hpp:73135
Definition: vulkan_structs.hpp:73231
Definition: vulkan_structs.hpp:73415
Definition: vulkan_structs.hpp:73824
Definition: vulkan_structs.hpp:73913
Definition: vulkan_structs.hpp:74014
Definition: vulkan_structs.hpp:74138
Definition: vulkan_structs.hpp:74237
Definition: vulkan_structs.hpp:74335
Definition: vulkan_structs.hpp:74457
Definition: vulkan_structs.hpp:74544
Definition: vulkan_structs.hpp:74640
Definition: vulkan_structs.hpp:74781
Definition: vulkan_structs.hpp:74871
Definition: vulkan_structs.hpp:74971
Definition: vulkan_structs.hpp:75081
Definition: vulkan_structs.hpp:75190
Definition: vulkan_structs.hpp:75273
Definition: vulkan_structs.hpp:75575
Definition: vulkan_structs.hpp:75673
Definition: vulkan_structs.hpp:75772
Definition: vulkan_structs.hpp:75870
Definition: vulkan_structs.hpp:75978
Definition: vulkan_structs.hpp:76065
Definition: vulkan_structs.hpp:76342
Definition: vulkan_structs.hpp:76441
Definition: vulkan_structs.hpp:76538
Definition: vulkan_structs.hpp:76634
Definition: vulkan_structs.hpp:76841
Definition: vulkan_structs.hpp:76967
Definition: vulkan_structs.hpp:77262
Definition: vulkan_structs.hpp:77347
Definition: vulkan_structs.hpp:77444
Definition: vulkan_structs.hpp:77527
Definition: vulkan_structs.hpp:77636
Definition: vulkan_structs.hpp:77723
Definition: vulkan_structs.hpp:77805
Definition: vulkan_structs.hpp:78035
Definition: vulkan_structs.hpp:78319
Definition: vulkan_structs.hpp:78429
Definition: vulkan_structs.hpp:78538
Definition: vulkan_structs.hpp:78692
Definition: vulkan_structs.hpp:78819
Definition: vulkan_structs.hpp:78918
Definition: vulkan_structs.hpp:79044
Definition: vulkan_structs.hpp:79144
Definition: vulkan_structs.hpp:79242
Definition: vulkan_structs.hpp:79329
Definition: vulkan_structs.hpp:79429
Definition: vulkan_structs.hpp:79550
Definition: vulkan_structs.hpp:79637
Definition: vulkan_structs.hpp:79746
Definition: vulkan_structs.hpp:79835
Definition: vulkan_structs.hpp:79935
Definition: vulkan_structs.hpp:80035
Definition: vulkan_structs.hpp:80133
Definition: vulkan_structs.hpp:80233
Definition: vulkan_structs.hpp:80335
Definition: vulkan_structs.hpp:80579
Definition: vulkan_structs.hpp:80819
Definition: vulkan_structs.hpp:80930
Definition: vulkan_structs.hpp:81038
Definition: vulkan_structs.hpp:81136
Definition: vulkan_structs.hpp:81227
Definition: vulkan_structs.hpp:81314
Definition: vulkan_structs.hpp:81472
Definition: vulkan_structs.hpp:81663
Definition: vulkan_structs.hpp:81865
Definition: vulkan_structs.hpp:81964
Definition: vulkan_structs.hpp:82118
Definition: vulkan_structs.hpp:82227
Definition: vulkan_structs.hpp:82337
Definition: vulkan_structs.hpp:82434
Definition: vulkan_structs.hpp:82535
Definition: vulkan_structs.hpp:82808
Definition: vulkan_structs.hpp:82908
Definition: vulkan_structs.hpp:83007
Definition: vulkan_structs.hpp:83093
Definition: vulkan_structs.hpp:83189
Definition: vulkan_structs.hpp:83277
Definition: vulkan_structs.hpp:83374
Definition: vulkan_structs.hpp:83459
Definition: vulkan_structs.hpp:83663
Definition: vulkan_structs.hpp:83764
Definition: vulkan_structs.hpp:83888
Definition: vulkan_structs.hpp:83984
Definition: vulkan_structs.hpp:84092
Definition: vulkan_structs.hpp:84182
Definition: vulkan_structs.hpp:84423
Definition: vulkan_structs.hpp:84534
Definition: vulkan_structs.hpp:84634
Definition: vulkan_structs.hpp:84733
Definition: vulkan_structs.hpp:84830
Definition: vulkan_structs.hpp:84913
Definition: vulkan_structs.hpp:85009
Definition: vulkan_structs.hpp:85108
Definition: vulkan_structs.hpp:85207
Definition: vulkan_structs.hpp:85306
Definition: vulkan_structs.hpp:85413
Definition: vulkan_structs.hpp:85514
Definition: vulkan_structs.hpp:85611
Definition: vulkan_structs.hpp:85711
Definition: vulkan_structs.hpp:85796
Definition: vulkan_structs.hpp:85900
Definition: vulkan_structs.hpp:86007
Definition: vulkan_structs.hpp:86147
Definition: vulkan_structs.hpp:86249
Definition: vulkan_structs.hpp:86361
Definition: vulkan_structs.hpp:86473
Definition: vulkan_structs.hpp:86557
Definition: vulkan_structs.hpp:86646
Definition: vulkan_structs.hpp:86877
Definition: vulkan_structs.hpp:86984
Definition: vulkan_structs.hpp:87081
Definition: vulkan_structs.hpp:87179
Definition: vulkan_structs.hpp:87413
Definition: vulkan_structs.hpp:87578
Definition: vulkan_structs.hpp:88253
Definition: vulkan_structs.hpp:88636
Definition: vulkan_structs.hpp:88906
Definition: vulkan_structs.hpp:89263
Definition: vulkan_structs.hpp:89534
Definition: vulkan_structs.hpp:89633
Definition: vulkan_structs.hpp:89729
Definition: vulkan_structs.hpp:90190
Definition: vulkan_structs.hpp:90314
Definition: vulkan_structs.hpp:90439
Definition: vulkan_structs.hpp:90537
Definition: vulkan_structs.hpp:90710
Definition: vulkan_structs.hpp:90822
Definition: vulkan_structs.hpp:90944
Definition: vulkan_structs.hpp:91116
Definition: vulkan_structs.hpp:91041
Definition: vulkan_structs.hpp:91266
Definition: vulkan_structs.hpp:91424
Definition: vulkan_structs.hpp:91530
Definition: vulkan_structs.hpp:91645
Definition: vulkan_structs.hpp:91806
Definition: vulkan_structs.hpp:91886
Definition: vulkan_structs.hpp:92012
Definition: vulkan_structs.hpp:92126
Definition: vulkan_structs.hpp:92237
Definition: vulkan_structs.hpp:33679
Definition: vulkan_structs.hpp:92601
Definition: vulkan_structs.hpp:92825
Definition: vulkan_structs.hpp:92937
Definition: vulkan_structs.hpp:93173
Definition: vulkan_structs.hpp:93273
Definition: vulkan_structs.hpp:93384
Definition: vulkan_structs.hpp:93655
Definition: vulkan_structs.hpp:93789
Definition: vulkan_structs.hpp:93901
Definition: vulkan_structs.hpp:94027
Definition: vulkan_structs.hpp:94142
Definition: vulkan_structs.hpp:94229
Definition: vulkan_structs.hpp:94419
Definition: vulkan_structs.hpp:94556
Definition: vulkan_structs.hpp:94705
Definition: vulkan_structs.hpp:94804
Definition: vulkan_structs.hpp:95040
Definition: vulkan_structs.hpp:95293
Definition: vulkan_structs.hpp:95518
Definition: vulkan_structs.hpp:95767
Definition: vulkan_structs.hpp:95884
Definition: vulkan_structs.hpp:96199
Definition: vulkan_structs.hpp:96299
Definition: vulkan_structs.hpp:96420
Definition: vulkan_structs.hpp:96503
Definition: vulkan_structs.hpp:96627
Definition: vulkan_structs.hpp:96726
Definition: vulkan_structs.hpp:96821
Definition: vulkan_structs.hpp:97219
Definition: vulkan_structs.hpp:97386
Definition: vulkan_structs.hpp:97517
Definition: vulkan_structs.hpp:97743
Definition: vulkan_structs.hpp:97881
Definition: vulkan_structs.hpp:97982
Definition: vulkan_structs.hpp:98080
Definition: vulkan_structs.hpp:98163
Definition: vulkan_structs.hpp:98246
Definition: vulkan_structs.hpp:98455
Definition: vulkan_structs.hpp:98540
Definition: vulkan_structs.hpp:98623
Definition: vulkan_structs.hpp:98967
Definition: vulkan_structs.hpp:99388
Definition: vulkan_structs.hpp:98859
Definition: vulkan_structs.hpp:98706
Definition: vulkan_structs.hpp:99247
Definition: vulkan_structs.hpp:96105
Definition: vulkan_structs.hpp:99615
Definition: vulkan_structs.hpp:99682
Definition: vulkan_structs.hpp:99820
Definition: vulkan_structs.hpp:101177
Definition: vulkan_structs.hpp:101432
Definition: vulkan_structs.hpp:101598
Definition: vulkan_structs.hpp:101528
Definition: vulkan_structs.hpp:101696
Definition: vulkan_structs.hpp:101794
Definition: vulkan_structs.hpp:101926
Definition: vulkan_structs.hpp:102211
Definition: vulkan_structs.hpp:102480
Definition: vulkan_structs.hpp:102384
Definition: vulkan_structs.hpp:102737
Definition: vulkan_structs.hpp:102943
Definition: vulkan_structs.hpp:102865
Definition: vulkan_structs.hpp:103041
Definition: vulkan_structs.hpp:103139
Definition: vulkan_structs.hpp:103307
Definition: vulkan_structs.hpp:103460
Definition: vulkan_structs.hpp:103570
Definition: vulkan_structs.hpp:103693
Definition: vulkan_structs.hpp:103896
Definition: vulkan.hpp:6687
T type
Definition: vulkan.hpp:6691
Definition: vulkan.hpp:6595
Definition: vulkan_structs.hpp:3014
Definition: vulkan_structs.hpp:6626
Definition: vulkan_structs.hpp:6709
Definition: vulkan_structs.hpp:104073
Definition: vulkan_structs.hpp:104184
Definition: vulkan_structs.hpp:104295
Definition: vulkan_structs.hpp:104658
Definition: vulkan_structs.hpp:104757
Definition: vulkan_structs.hpp:104849
Definition: vulkan_structs.hpp:104949
Definition: vulkan_structs.hpp:105126
Definition: vulkan_structs.hpp:105211
Definition: vulkan_structs.hpp:105310
Definition: vulkan_structs.hpp:105857
Definition: vulkan_structs.hpp:106193
Definition: vulkan_structs.hpp:102606
Definition: vulkan_structs.hpp:106299
Definition: vulkan_structs.hpp:106407
Definition: vulkan_structs.hpp:106577
Definition: vulkan_structs.hpp:106774
Definition: vulkan_structs.hpp:106880
Definition: vulkan_structs.hpp:106955
Definition: vulkan_structs.hpp:107407
Definition: vulkan_structs.hpp:107496
Definition: vulkan_structs.hpp:107594
Definition: vulkan_structs.hpp:107677
Definition: vulkan_structs.hpp:94932
Definition: vulkan_structs.hpp:107773
Definition: vulkan_structs.hpp:107932
Definition: vulkan_structs.hpp:108105
Definition: vulkan_structs.hpp:108311
Definition: vulkan_structs.hpp:108633
Definition: vulkan_structs.hpp:108852
Definition: vulkan_structs.hpp:101007
Definition: vulkan_structs.hpp:100711
Definition: vulkan_structs.hpp:108948
Definition: vulkan_structs.hpp:109074
Definition: vulkan_structs.hpp:109158
Definition: vulkan_structs.hpp:109287
Definition: vulkan_structs.hpp:102123
Definition: vulkan_structs.hpp:109369
Definition: vulkan_structs.hpp:109455
Definition: vulkan_structs.hpp:109537
Definition: vulkan_structs.hpp:109621
Definition: vulkan_structs.hpp:109882
Definition: vulkan_structs.hpp:109763
Definition: vulkan_structs.hpp:110065
Definition: vulkan_structs.hpp:110234
Definition: vulkan_structs.hpp:110163
Definition: vulkan_structs.hpp:110512
Definition: vulkan_structs.hpp:110636
Definition: vulkan_structs.hpp:110733
Definition: vulkan_structs.hpp:110879
Definition: vulkan_structs.hpp:110976
Definition: vulkan_structs.hpp:111074
Definition: vulkan_structs.hpp:111394
Definition: vulkan_structs.hpp:111492
Definition: vulkan_structs.hpp:111588
Definition: vulkan_structs.hpp:111686
Definition: vulkan_structs.hpp:111810
Definition: vulkan_structs.hpp:111934
Definition: vulkan_structs.hpp:112059
Definition: vulkan_structs.hpp:112182
Definition: vulkan_structs.hpp:112265
Definition: vulkan_structs.hpp:112381
Definition: vulkan_structs.hpp:112547
Definition: vulkan_structs.hpp:112786
Definition: vulkan_structs.hpp:2439
Definition: vulkan_structs.hpp:112885
Definition: vulkan_structs.hpp:113025
Definition: vulkan_structs.hpp:113194
Definition: vulkan_structs.hpp:113319
Definition: vulkan_structs.hpp:113449
Definition: vulkan_structs.hpp:94331
Definition: vulkan_structs.hpp:113926
Definition: vulkan_structs.hpp:114095
Definition: vulkan_structs.hpp:114226
Definition: vulkan_structs.hpp:114323
Definition: vulkan_structs.hpp:114406
Definition: vulkan_structs.hpp:114501
Definition: vulkan_structs.hpp:114599
Definition: vulkan_structs.hpp:114737
Definition: vulkan_structs.hpp:114857
Definition: vulkan_structs.hpp:115020
Definition: vulkan_structs.hpp:115143
Definition: vulkan_structs.hpp:115231
Definition: vulkan_structs.hpp:115329
Definition: vulkan_structs.hpp:115471
Definition: vulkan_structs.hpp:115573
Definition: vulkan_structs.hpp:115769
Definition: vulkan_structs.hpp:115902
Definition: vulkan_structs.hpp:116107
Definition: vulkan_structs.hpp:116204
Definition: vulkan_structs.hpp:116323
Definition: vulkan_structs.hpp:116506
Definition: vulkan_structs.hpp:116604
Definition: vulkan_structs.hpp:116698
Definition: vulkan_structs.hpp:116829
Definition: vulkan_structs.hpp:116935
Definition: vulkan_structs.hpp:117091
Definition: vulkan_structs.hpp:117193
Definition: vulkan_structs.hpp:117287
Definition: vulkan_structs.hpp:117419
Definition: vulkan_structs.hpp:117559
Definition: vulkan_structs.hpp:117710
Definition: vulkan_structs.hpp:117825
Definition: vulkan_structs.hpp:117988
Definition: vulkan_structs.hpp:118111
Definition: vulkan_structs.hpp:118199
Definition: vulkan_structs.hpp:118329
Definition: vulkan_structs.hpp:118534
Definition: vulkan_structs.hpp:118632
Definition: vulkan_structs.hpp:118726
Definition: vulkan_structs.hpp:118857
Definition: vulkan_structs.hpp:118964
Definition: vulkan_structs.hpp:119109
Definition: vulkan_structs.hpp:119211
Definition: vulkan_structs.hpp:119305
Definition: vulkan_structs.hpp:119431
Definition: vulkan_structs.hpp:119571
Definition: vulkan_structs.hpp:119722
Definition: vulkan_structs.hpp:119837
Definition: vulkan_structs.hpp:120033
Definition: vulkan_structs.hpp:120166
Definition: vulkan_structs.hpp:120261
Definition: vulkan_structs.hpp:120411
Definition: vulkan_structs.hpp:120637
Definition: vulkan_structs.hpp:120733
Definition: vulkan_structs.hpp:120948
Definition: vulkan_structs.hpp:120823
Definition: vulkan_structs.hpp:121131
Definition: vulkan_structs.hpp:121214
Definition: vulkan_structs.hpp:121312
Definition: vulkan_structs.hpp:121434
Definition: vulkan_structs.hpp:121530
Definition: vulkan_structs.hpp:121637
Definition: vulkan_structs.hpp:113686
Definition: vulkan_structs.hpp:86745
Definition: vulkan_structs.hpp:121753
Definition: vulkan_structs.hpp:113816
Definition: vulkan_structs.hpp:121877
Definition: vulkan_structs.hpp:122070
Definition: vulkan_structs.hpp:122156
Definition: vulkan_structs.hpp:122278
Definition: vulkan_structs.hpp:95187
Definition: vulkan_structs.hpp:95435
Definition: vulkan_structs.hpp:123149
Definition: vulkan_structs.hpp:123280
Definition: vulkan_structs.hpp:123411
Definition: vulkan_structs.hpp:42334
Definition: vulkan_handles.hpp:2350
Definition: vulkan_structs.hpp:515
Definition: vulkan_structs.hpp:3385
Definition: vulkan_structs.hpp:24034
Definition: vulkan_structs.hpp:30192
Definition: vulkan_structs.hpp:139
Definition: vulkan_structs.hpp:680
Definition: vulkan_structs.hpp:55461
Definition: vulkan_structs.hpp:55943
Definition: vulkan_structs.hpp:91743
module
Definition: vulkan.cppm:11
uint64_t VkVideoSessionParametersKHR
Definition: vulkan_core.h:7946
uint64_t VkImage
Definition: vulkan_core.h:100
uint64_t VkSurfaceKHR
Definition: vulkan_core.h:7513
uint64_t VkShaderModule
Definition: vulkan_core.h:113
uint64_t VkQueryPool
Definition: vulkan_core.h:110
uint64_t VkMicromapEXT
Definition: vulkan_core.h:16913
uint64_t VkIndirectCommandsLayoutNV
Definition: vulkan_core.h:15109
uint64_t VkSampler
Definition: vulkan_core.h:119
uint64_t VkRenderPass
Definition: vulkan_core.h:117
uint64_t VkCommandPool
Definition: vulkan_core.h:123
uint64_t VkPipelineCache
Definition: vulkan_core.h:114
uint64_t VkEvent
Definition: vulkan_core.h:109
uint64_t VkBuffer
Definition: vulkan_core.h:99
uint64_t VkCuModuleNVX
Definition: vulkan_core.h:11781
struct VkPhysicalDevice_T * VkPhysicalDevice
Definition: vulkan_core.h:102
uint64_t VkFramebuffer
Definition: vulkan_core.h:122
uint64_t VkBufferView
Definition: vulkan_core.h:111
uint64_t VkCudaModuleNV
Definition: vulkan_core.h:15632
struct VkQueue_T * VkQueue
Definition: vulkan_core.h:104
uint64_t VkDisplayKHR
Definition: vulkan_core.h:7789
uint64_t VkDisplayModeKHR
Definition: vulkan_core.h:7790
struct VkInstance_T * VkInstance
Definition: vulkan_core.h:101
struct VkDevice_T * VkDevice
Definition: vulkan_core.h:103
uint64_t VkDeferredOperationKHR
Definition: vulkan_core.h:10293
uint64_t VkOpticalFlowSessionNV
Definition: vulkan_core.h:18087
uint64_t VkFence
Definition: vulkan_core.h:107
uint64_t VkDescriptorSet
Definition: vulkan_core.h:120
void(* PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2925
uint64_t VkDescriptorPool
Definition: vulkan_core.h:121
uint64_t VkAccelerationStructureNV
Definition: vulkan_core.h:13282
uint64_t VkSwapchainKHR
Definition: vulkan_core.h:7628
uint64_t VkPipelineLayout
Definition: vulkan_core.h:115
uint64_t VkShaderEXT
Definition: vulkan_core.h:18276
uint64_t VkDescriptorUpdateTemplate
Definition: vulkan_core.h:4857
uint64_t VkDescriptorSetLayout
Definition: vulkan_core.h:118
uint64_t VkAccelerationStructureKHR
Definition: vulkan_core.h:15736
uint64_t VkCudaFunctionNV
Definition: vulkan_core.h:15633
uint64_t VkSamplerYcbcrConversion
Definition: vulkan_core.h:4856
uint64_t VkPipeline
Definition: vulkan_core.h:116
uint64_t VkDebugUtilsMessengerEXT
Definition: vulkan_core.h:12652
struct VkCommandBuffer_T * VkCommandBuffer
Definition: vulkan_core.h:106
uint64_t VkDebugReportCallbackEXT
Definition: vulkan_core.h:11447
uint64_t VkSemaphore
Definition: vulkan_core.h:105
#define VK_NULL_HANDLE
Definition: vulkan_core.h:46
uint64_t VkCuFunctionNVX
Definition: vulkan_core.h:11782
uint64_t VkPrivateDataSlot
Definition: vulkan_core.h:6482
uint64_t VkPerformanceConfigurationINTEL
Definition: vulkan_core.h:14063
uint64_t VkImageView
Definition: vulkan_core.h:112
uint64_t VkDeviceMemory
Definition: vulkan_core.h:108
uint64_t VkValidationCacheEXT
Definition: vulkan_core.h:13099
uint64_t VkVideoSessionKHR
Definition: vulkan_core.h:7945
std::enable_if< vk::isVulkanHandleType< T >::value, bool >::type operator!=(const T &v, std::nullptr_t)
Definition: vulkan_handles.hpp:16178
std::enable_if< vk::isVulkanHandleType< T >::value, bool >::type operator==(const T &v, std::nullptr_t)
Definition: vulkan_handles.hpp:16166
#define VULKAN_HPP_CONST_OR_CONSTEXPR
Definition: vulkan_hpp_macros.hpp:156
#define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
Definition: vulkan_hpp_macros.hpp:196
#define VULKAN_HPP_NODISCARD
Definition: vulkan_hpp_macros.hpp:195
#define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
Definition: vulkan_hpp_macros.hpp:176
#define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE
Definition: vulkan_hpp_macros.hpp:266
#define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
Definition: vulkan_hpp_macros.hpp:276
#define VULKAN_HPP_TYPESAFE_EXPLICIT
Definition: vulkan_hpp_macros.hpp:137
#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
Definition: vulkan_hpp_macros.hpp:277
#define VULKAN_HPP_CONSTEXPR
Definition: vulkan_hpp_macros.hpp:154
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan_hpp_macros.hpp:171
#define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
Definition: vulkan_hpp_macros.hpp:275